home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 27 / CU Amiga Magazine's Super CD-ROM 27 (1998)(EMAP Images)(GB)[!][issue 1998-10].iso / CUCD / Programming / FreshBar / Source / SIFC_Strings.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-08-01  |  134.5 KB  |  5,332 lines
  1. //****************************************************************//
  2. // Filename:    SIFC_Strings.cpp
  3. // Autor:       Christian Taulien of Strange Intelligence
  4. // Purpose:     Implementierung der StringC Klasse
  5. // Creation:    27. Mai 1997
  6. //****************************************************************//
  7. #define RCSID_SIFC_STRINGS_CPP "$Id: SIFC_Strings.cpp 1.23 1998/04/20 02:44:01 Christian_Taulien Exp Christian_Taulien $"
  8.  
  9. #include "SIFC_Strings.h"
  10. #include <stdio.h>
  11. #include <pragma/utility_lib.h>
  12.  
  13. //#ifdef si_debug
  14. //#undef si_debug
  15. //#define si_debug_x
  16. //#endif
  17.  
  18. /*S*/ // stringc-needed macros
  19. #ifndef SIFC_MAX
  20. # define SIFC_MAX(a,b) ((a)>(b) ? (a) : (b))
  21. #endif
  22.  
  23. void dummyFunc(void *,...) {};
  24.  
  25. #ifndef SIFC_MIN
  26. # define SIFC_MIN(a,b) ((a)<(b) ? (a) : (b))
  27. #endif
  28.  
  29. #ifndef TRACEMETHOD
  30. # ifdef si_debug
  31. #  define TRACEMETHOD cout << __FUNC__ " [this: " << (void *) this << "]" << endl;
  32. # else
  33. #  define TRACEMETHOD
  34. # endif
  35. #endif
  36.  
  37. // TRACE-Macro
  38. #ifndef TRACE
  39. # ifdef si_debug
  40. #  define TRACE printf
  41. # else
  42. #  define TRACE ::dummyFunc
  43. # endif
  44. #endif
  45.  
  46. #ifndef ASSERT
  47. # ifdef si_asserts
  48. #  define ASSERT(condition) if (!(condition)) \
  49.    {\
  50.       cout << "!!!Assertion failed: \"" << #condition << "\", in file " << __FILE__ << " line " << __LINE__ << endl;\
  51.    }
  52. # else
  53. #  define ASSERT(contition)
  54. # endif
  55. #endif
  56.  
  57. #define STRINGC_XC "stringc-class-exception"
  58. /*E*/
  59.  
  60. StringDataC glob_oEmptyStringData =
  61. {
  62.   "",
  63.   0,
  64.   0,
  65.   1
  66. };
  67.  
  68. const char *StringC::m_asStringTable[StringC::STRINGC_AccessLast] =
  69. /*S*/
  70. {
  71.   "tried to access a char not in bufferrange",
  72.   "not enough memory for string addition",
  73.   "write access on empty string",
  74.   "illegal use of zero-string length"
  75. };
  76. /*E*/
  77.  
  78. // private methods -------------------------------------------------
  79. const char *StringC::getStringTableEntry(ULONG arg_ulIndex)
  80. /*S*/
  81. /*S*/ /* Methoden-Rahmen */
  82. /*************************************************************************
  83. * Name der Methode: getStringTableEntry()
  84. *
  85. * Klasse: StringC
  86. *
  87. * Funktion: ermittelt einen Bibliotheken-String
  88. *
  89. * Zugriff: private
  90. *
  91. * Eingabe-Parameter: 1
  92. *   ULONG arg_ulIndex:  Der Index des gewünschten Strings
  93. *       [0...STRINGC_Last aus der enum-Anweisung]
  94. *
  95. * Ausgabe-Parameter: const char *: Zeiger auf den ermittelten String
  96. *
  97. * Aufgerufen von: -
  98. *
  99. * Verwendung folgender globaler Variablen/Strukturen: 1
  100. *   global_sSpecialErr_WrongStringID: Zeiger auf Text für schweren Fehler
  101. *
  102. * Benutzte Methoden: -
  103. *
  104. * Version: 1.0
  105. *
  106. * Autor: Christian Taulien of Strange Intelligence
  107. *
  108. * Datum:  4. Juni 1997
  109. *
  110. * Letzte Änderungen/Neuerungen:
  111. *  4. Juni 1997:  Methode definiert
  112. *
  113. *************************************************************************/
  114. /*E*/
  115. {
  116. ASSERT(arg_ulIndex < STRINGC_Last)
  117.  
  118.   // if the index is smaller than STRINGC_Last (max. ID)
  119.   if (arg_ulIndex < STRINGC_Last)
  120.   {
  121.     // return the wanted string
  122.     return(m_asStringTable[arg_ulIndex]);
  123.   }
  124.   else
  125.   {
  126.     // return a heavy-error-message
  127.     return("###");
  128.   } // if (arg_ulIndex < STRINGC_Last)
  129. }
  130. /*E*/
  131.  
  132. BOOL StringC::isFilled()
  133. /*S*/
  134. /*S*/ /* Methoden-Rahmen */
  135. /*************************************************************************
  136. * Name der Methode:
  137. *
  138. * Klasse:
  139. *
  140. * Funktion:
  141. *
  142. * Zugriff:
  143. *
  144. * Eingabe-Parameter:
  145. *
  146. * Ausgabe-Parameter:
  147. *
  148. * Aufgerufen von:
  149. *
  150. * Verwendung folgender globaler Variablen/Strukturen:
  151. *
  152. * Benutzte Methoden:
  153. *
  154. * Version: 1.0
  155. *
  156. * Autor: Christian Taulien of Strange Intelligence
  157. *
  158. * Datum:  1. April 1998
  159. *
  160. * Letzte Änderungen/Neuerungen:
  161. *  1. April 1998: Methode definiert
  162. *
  163. *************************************************************************/
  164. /*E*/
  165. {
  166. TRACEMETHOD
  167. ASSERT(m_poData)
  168. return m_poData != &glob_oEmptyStringData;
  169. }
  170. /*E*/
  171. BOOL StringC::isMultiUsed()
  172. /*S*/
  173. /*S*/ /* Methoden-Rahmen */
  174. /*************************************************************************
  175. * Name der Methode:
  176. *
  177. * Klasse:
  178. *
  179. * Funktion:
  180. *
  181. * Zugriff:
  182. *
  183. * Eingabe-Parameter:
  184. *
  185. * Ausgabe-Parameter:
  186. *
  187. * Aufgerufen von:
  188. *
  189. * Verwendung folgender globaler Variablen/Strukturen:
  190. *
  191. * Benutzte Methoden:
  192. *
  193. * Version: 1.0
  194. *
  195. * Autor: Christian Taulien of Strange Intelligence
  196. *
  197. * Datum:  1. April 1998
  198. *
  199. * Letzte Änderungen/Neuerungen:
  200. *  1. April 1998: Methode definiert
  201. *
  202. *************************************************************************/
  203. /*E*/
  204. {
  205. TRACEMETHOD
  206. ASSERT(m_poData);
  207. return m_poData->m_lRefs > 1 ? TRUE : FALSE;
  208. }
  209. /*E*/
  210. void StringC::decReference()
  211. /*S*/
  212. /*S*/ /* Methoden-Rahmen */
  213. /*************************************************************************
  214. * Name der Methode:
  215. *
  216. * Klasse:
  217. *
  218. * Funktion:
  219. *
  220. * Zugriff:
  221. *
  222. * Eingabe-Parameter:
  223. *
  224. * Ausgabe-Parameter:
  225. *
  226. * Aufgerufen von:
  227. *
  228. * Verwendung folgender globaler Variablen/Strukturen:
  229. *
  230. * Benutzte Methoden:
  231. *
  232. * Version: 1.0
  233. *
  234. * Autor: Christian Taulien of Strange Intelligence
  235. *
  236. * Datum:  1. April 1998
  237. *
  238. * Letzte Änderungen/Neuerungen:
  239. *  1. April 1998: Methode definiert
  240. *
  241. *************************************************************************/
  242. /*E*/
  243. {
  244. TRACEMETHOD
  245. ASSERT(checkInstance());
  246.  
  247.   // if we are not the default pointer
  248.   if (isFilled() && isMultiUsed())
  249.   {
  250.     // increment the reference counter
  251.     m_poData->m_lRefs--;
  252.   } // if
  253. }
  254. /*E*/
  255. void StringC::incReference()
  256. /*S*/
  257. /*S*/ /* Methoden-Rahmen */
  258. /*************************************************************************
  259. * Name der Methode:
  260. *
  261. * Klasse:
  262. *
  263. * Funktion:
  264. *
  265. * Zugriff:
  266. *
  267. * Eingabe-Parameter:
  268. *
  269. * Ausgabe-Parameter:
  270. *
  271. * Aufgerufen von:
  272. *
  273. * Verwendung folgender globaler Variablen/Strukturen:
  274. *
  275. * Benutzte Methoden:
  276. *
  277. * Version: 1.0
  278. *
  279. * Autor: Christian Taulien of Strange Intelligence
  280. *
  281. * Datum:  1. April 1998
  282. *
  283. * Letzte Änderungen/Neuerungen:
  284. *  1. April 1998: Methode definiert
  285. *
  286. *************************************************************************/
  287. /*E*/
  288. {
  289. TRACEMETHOD
  290. ASSERT(checkInstance());
  291.  
  292.   // if we are not the default pointer
  293.   if (isFilled())
  294.   {
  295.     // increment the reference counter
  296.     m_poData->m_lRefs++;
  297.   } // if
  298. }
  299. /*E*/
  300. void StringC::prepareModify()
  301. /*S*/
  302. /*S*/ /* Methoden-Rahmen */
  303. /*************************************************************************
  304. * Name der Methode:
  305. *
  306. * Klasse:
  307. *
  308. * Funktion:
  309. *
  310. * Zugriff:
  311. *
  312. * Eingabe-Parameter:
  313. *
  314. * Ausgabe-Parameter:
  315. *
  316. * Aufgerufen von:
  317. *
  318. * Verwendung folgender globaler Variablen/Strukturen:
  319. *
  320. * Benutzte Methoden:
  321. *
  322. * Version: 1.0
  323. *
  324. * Autor: Christian Taulien of Strange Intelligence
  325. *
  326. * Datum:  2. April 1998
  327. *
  328. * Letzte Änderungen/Neuerungen:
  329. *  2. April 1998: Methode definiert
  330. *
  331. *************************************************************************/
  332. /*E*/
  333. {    
  334. TRACEMETHOD
  335. ASSERT(checkInstance())
  336.  
  337.   // if the object is empty or multiused
  338.   if (!isFilled() || isMultiUsed())
  339.   {
  340.     // allocate a new data-object
  341.     StringDataC *poNewData = new StringDataC;
  342.     if (!poNewData)
  343.     {
  344.       throw STRINGC_XC;
  345.     } // if
  346.  
  347.     // take over the datas
  348.     poNewData->m_ulStrLen = m_poData->m_ulStrLen;
  349.     poNewData->m_ulBufLen = SIFC_MAX(m_poData->m_ulBufLen,8);
  350.     poNewData->m_lRefs    = 1;
  351.  
  352.     // allocate the buffer
  353.     poNewData->m_sStrPtr = new char [m_poData->m_ulBufLen+1];
  354.     if (!poNewData->m_sStrPtr)
  355.     {
  356.       delete poNewData;
  357.       throw STRINGC_XC;
  358.     }
  359.       // ... and copy the string
  360.     memcpy(poNewData->m_sStrPtr, m_poData->m_sStrPtr, poNewData->m_ulBufLen);
  361.     poNewData->m_sStrPtr[poNewData->m_ulStrLen] = '\0';
  362.  
  363.     // from now on, we're changed to the new buffer
  364.     m_poData = poNewData;
  365.   } // if
  366. }
  367. /*E*/
  368. StringC::StringC(ULONG arg_ulStrLen, ULONG arg_ulBufLen, char *arg_sStrPtr)
  369. /*S*/
  370. /*S*/ /* Methoden-Rahmen */
  371. /*************************************************************************
  372. * Name der Methode:
  373. *
  374. * Klasse:
  375. *
  376. * Funktion:
  377. *
  378. * Zugriff:
  379. *
  380. * Eingabe-Parameter:
  381. *
  382. * Ausgabe-Parameter:
  383. *
  384. * Aufgerufen von:
  385. *
  386. * Verwendung folgender globaler Variablen/Strukturen:
  387. *
  388. * Benutzte Methoden:
  389. *
  390. * Version: 1.0
  391. *
  392. * Autor: Christian Taulien of Strange Intelligence
  393. *
  394. * Datum:  1. April 1998
  395. *
  396. * Letzte Änderungen/Neuerungen:
  397. *  1. April 1998: Methode definiert
  398. *
  399. *************************************************************************/
  400. /*E*/
  401. {
  402. TRACEMETHOD
  403.   m_poData = new StringDataC;
  404.   if (!m_poData)
  405.   {
  406.     throw STRINGC_XC;
  407.   } // if
  408.  
  409.   m_poData->m_sStrPtr  = arg_sStrPtr;
  410.   m_poData->m_ulStrLen = arg_ulStrLen;
  411.   m_poData->m_ulBufLen = arg_ulBufLen;
  412.   m_poData->m_lRefs    = 1;
  413. }
  414. /*E*/
  415.  
  416. // protected methods -----------------------------------------------
  417. #ifdef si_debug
  418. void StringC::dumpContext(void) const
  419. /*S*/
  420. /*S*/ /* Methoden-Rahmen */
  421. /*************************************************************************
  422. * Name der Methode: dumpContext()
  423. *
  424. * Klasse: StringC
  425. *
  426. * Funktion: gibt den Inhalt der Datenmember nach cout aus
  427. *
  428. * Zugriff: protected
  429. *
  430. * Eingabe-Parameter: -
  431. *
  432. * Ausgabe-Parameter: -
  433. *
  434. * Aufgerufen von: -
  435. *
  436. * Verwendung folgender globaler Variablen/Strukturen: -
  437. *
  438. * Benutzte Methoden: -
  439. *
  440. * Version: 1.0
  441. *
  442. * Autor: Christian Taulien of Strange Intelligence
  443. *
  444. * Datum: 28. Mai 1997
  445. *
  446. * Letzte Änderungen/Neuerungen:
  447. *   28. Mai 1997:   Methode definiert
  448. *
  449. *************************************************************************/
  450. /*E*/
  451. {
  452. ASSERT(checkInstance())
  453.   cout << "+++ StringC-Datenmembers: +++" << endl;
  454.   cout << "StringC::m_sStrPtr=\t\t" << (void *) m_poData->m_sStrPtr << endl;
  455.   cout << "StringC::m_ulStrLen=\t\t" << m_poData->m_ulStrLen << endl;
  456.   cout << "StringC::m_ulBufLen=\t\t" << m_poData->m_ulBufLen << endl;
  457.   cout << "StringC::m_rRefs=\t\t\t" << m_poData->m_lRefs << endl;
  458.   cout << "+++ StringC dump complete " << endl;
  459. }
  460. /*E*/
  461. #endif
  462. void StringC::initStringC(const char *arg_sStrPtr, ULONG arg_ulBufLen)
  463. /*S*/
  464. /*S*/ /* Methoden-Rahmen */
  465. /*************************************************************************
  466. * Name der Methode: initStringC()  [Nr. 1]
  467. *
  468. * Klasse: StringC
  469. *
  470. * Funktion: initialisiert ein Objekt anhand eines Quellpointers und
  471. *   einer Bufferlänge
  472. *
  473. * Zugriff: protected
  474. *
  475. * Eingabe-Parameter: 2
  476. *   char *arg_sStrPtr:  Der Zeiger auf den Quell-String (wird kopiert)
  477. *   ULONG arg_ulBufLen:   Gewünschte Länge des Buffers
  478. *
  479. * Ausgabe-Parameter: -
  480. *
  481. * Aufgerufen von: -
  482. *
  483. * Verwendung folgender globaler Variablen/Strukturen: -
  484. *
  485. * Benutzte Methoden: 4
  486. *   initInstance()
  487. *   allocBuffer()
  488. *   string.h/strlen()
  489. *   string.h/strncpy()
  490. *
  491. * Version: 1.0
  492. *
  493. * Autor: Christian Taulien of Strange Intelligence
  494. *
  495. * Datum: 28. Mai 1997
  496. *
  497. * Letzte Änderungen/Neuerungen:
  498. *   28. Mai 1997:     Methode definiert
  499. *
  500. *************************************************************************/
  501. /*E*/
  502. {
  503. TRACEMETHOD
  504. ASSERT(arg_sStrPtr)
  505.  
  506.   // Init & Alloc
  507.   initInstance();
  508.  
  509.   // for safety reasons an additional byte must be allocated
  510.   allocBuffer(arg_ulBufLen);
  511.  
  512.   // Compute the new string length, but maximal the new buflength
  513.   ULONG lStrLen=SIFC_MIN(arg_ulBufLen, strlen(arg_sStrPtr));
  514.  
  515.   // copy the source-string
  516.   strncpy(m_poData->m_sStrPtr, arg_sStrPtr, lStrLen);
  517.  
  518.   // init the values
  519.   m_poData->m_ulStrLen=lStrLen;       // the new string length
  520.   m_poData->m_sStrPtr[lStrLen]=0;     // set the terminating byte
  521. }
  522. /*E*/
  523. void StringC::initStringC(ULONG arg_ulBufLen)
  524. /*S*/
  525. /*S*/ /* Methoden-Rahmen */
  526. /*************************************************************************
  527. * Name der Methode: initStringC()  [Nr. 2]
  528. *
  529. * Klasse: StringC
  530. *
  531. * Funktion: Initialisiert das Objekt anhand einer Buffer-Größe
  532. *
  533. * Zugriff: protected
  534. *
  535. * Eingabe-Parameter: 1
  536. *   ULONG arg_ulBufLen: Gewünschte Größe des Buffers
  537. *
  538. * Ausgabe-Parameter: -
  539. *
  540. * Aufgerufen von: -
  541. *
  542. * Verwendung folgender globaler Variablen/Strukturen: -
  543. *
  544. * Benutzte Methoden: 2
  545. *   allocBuffer()
  546. *   initInstance()
  547. *
  548. * Version: 1.1
  549. *
  550. * Autor: Christian Taulien of Strange Intelligence
  551. *
  552. * Datum: 25. Juni 1997
  553. *
  554. * Letzte Änderungen/Neuerungen:
  555. *   28. Mai 1997:   Methode definiert
  556. *   25. Juni 1997:  memset() wird nun von allocBuffer() übernommen.
  557. *
  558. *************************************************************************/
  559. /*E*/
  560. {
  561. TRACEMETHOD
  562. // Parameter-Check
  563. ASSERT(arg_ulBufLen)
  564.  
  565.   // Init & Alloc
  566.   initInstance();
  567.   // allocate buffer and initialize it with zeros
  568.   allocBuffer(arg_ulBufLen);
  569. }
  570. /*E*/
  571. void StringC::allocBuffer(ULONG arg_ulSize)
  572. /*S*/
  573. /*S*/ /* Methoden-Rahmen */
  574. /*************************************************************************
  575. * Name der Methode: allocBuffer()
  576. *
  577. * Klasse: StringC
  578. *
  579. * Funktion: alloziert Speicher für den String-Object-Buffer
  580. *       Achtung: Wenn nicht genug Mem, dann wird eine XC geschmissen
  581. *
  582. * Zugriff: protected
  583. *
  584. * Eingabe-Parameter: 1
  585. *   ULONG arg_ulSize: Die Größe des Buffers in Bytes. NULL für Speicher
  586. *             freigeben
  587. *
  588. * Ausgabe-Parameter: -
  589. *
  590. * Aufgerufen von: -
  591. *
  592. * Verwendung folgender globaler Variablen/Strukturen: 1
  593. *   global_sCommonErr_NoMem - bei Übergabe an XC
  594. *
  595. * Benutzte Methoden: 4
  596. *   freeBuffer()
  597. *   isMultiUsed()
  598. *   ObjectXC::ObjectXC()
  599. *   string.h/memset()
  600. *
  601. * Version: 3.0
  602. *
  603. * Autor: Christian Taulien of Strange Intelligence
  604. *
  605. * Datum:  1. April 1998
  606. *
  607. * Letzte Änderungen/Neuerungen:
  608. *   27. Mai 1997:   Methode definiert
  609. *  4. Juni 1997:  Speichermanagement verbessert. Es wird nur noch dann
  610. *           neuer Speicher reserviert, wenn der alte Buffer nicht
  611. *           groß genug für den neuen ist. Um Buffer explizit zu
  612. *           schmälern sollte zuvor freeBuffer() aufgerufen werden
  613. *  1. April 1998: Speichermanagement für StringArrayC angepasst
  614. *
  615. *************************************************************************/
  616. /*E*/
  617. {
  618. TRACEMETHOD
  619.  
  620.   // a size of zero means freeBuffer()
  621.   if (!arg_ulSize)
  622.   {
  623.     freeBuffer();
  624.     return;
  625.   } // if (!arg_ulSize)
  626.  
  627.   // A new buffer can't contain a string yet
  628.   m_poData->m_ulStrLen=0;
  629.  
  630.   // If multiused or the existing buffer is not big enough
  631.   if (isMultiUsed() || m_poData->m_ulBufLen < arg_ulSize)
  632.   {
  633.     // free the old buffer
  634.     freeBuffer();
  635.  
  636.     // allocate a new big one
  637.     // (dividable by 8 and mind 1 bigger than wanted)
  638.     ULONG ulSize=(arg_ulSize+8) & (~0x7);
  639.     m_poData = new StringDataC;
  640.  
  641.     if (!m_poData)
  642.     {
  643.       throw STRINGC_XC;
  644.     } // if
  645.  
  646.     m_poData->m_sStrPtr = new char [ulSize];
  647.     if (!m_poData->m_sStrPtr)
  648.     {
  649.       // if the string-buffer could not be allocated
  650.       delete m_poData;
  651.       throw STRINGC_XC;
  652.     } // if
  653.  
  654.     m_poData->m_ulBufLen = ulSize-1; // one wall-byte
  655.     m_poData->m_lRefs = 1;
  656.   } // if (m_ulBufLen < arg_ulSize)
  657.  
  658.   // always set the Bytes in the buffer to zero
  659.   memset(m_poData->m_sStrPtr, 0, m_poData->m_ulBufLen+1);
  660. }
  661. /*E*/
  662. void StringC::freeBuffer(void)
  663. /*S*/
  664. /*S*/ /* Methoden-Rahmen */
  665. /*************************************************************************
  666. * Name der Methode: freeBuffer(void)
  667. *
  668. * Klasse: StringC
  669. *
  670. * Funktion: Gibt den Puffer-Speicher eines String-Objekts frei und init-
  671. *   ialisiert es wieder.
  672. *
  673. * Zugriff: protected
  674. *
  675. * Eingabe-Parameter: -
  676. *
  677. * Ausgabe-Parameter: -
  678. *
  679. * Aufgerufen von:
  680. *
  681. * Verwendung folgender globaler Variablen/Strukturen: -
  682. *
  683. * Benutzte Methoden: 3
  684. *   isFilled()
  685. *   isMultiUsed()
  686. *   initInstance()
  687. *
  688. * Version: 2.0
  689. *
  690. * Autor: Christian Taulien of Strange Intelligence
  691. *
  692. * Datum:  1. April 1998
  693. *
  694. * Letzte Änderungen/Neuerungen:
  695. *   27. Mai 1997:   Methode definiert
  696. *    1. April 1998: Speichermanagement für StringArrayC angepasst.
  697. *
  698. *************************************************************************/
  699. /*E*/
  700. {
  701. TRACEMETHOD
  702. ASSERT(m_poData)
  703. ASSERT(m_poData->m_sStrPtr)
  704.  
  705.   // if we have a pointer to a string-data-object
  706.   if (isFilled())
  707.   {
  708.     // if the reference pointer
  709.     if (isMultiUsed())
  710.     {
  711.       decReference();
  712.     }
  713.     else
  714.     {
  715.       // if there is something to free
  716.       if (m_poData->m_ulBufLen)
  717.       {
  718.         delete [] m_poData->m_sStrPtr;
  719.       } // if
  720.       delete m_poData;
  721.     } // if
  722.  
  723.     initInstance();
  724.   } // if
  725. }
  726. /*E*/
  727. void StringC::resizeBuffer(ULONG arg_ulSize)
  728. /*S*/
  729. /*S*/ /* Methoden-Rahmen */
  730. /*************************************************************************
  731. * Name der Methode: resizeBuffer()
  732. *
  733. * Klasse: StringC
  734. *
  735. * Funktion: Verändert die Größe des Buffers
  736. *
  737. * Zugriff: protected
  738. *
  739. * Eingabe-Parameter: 1
  740. *   ULONG arg_ulSize:   Die neue Größe des Buffers
  741. *
  742. * Ausgabe-Parameter: -
  743. *
  744. * Aufgerufen von: -
  745. *
  746. * Verwendung folgender globaler Variablen/Strukturen: -
  747. *
  748. * Benutzte Methoden: 2
  749. *   releaseBuffer()
  750. *   initStringC()
  751. *
  752. * Version: 1.0
  753. *
  754. * Autor: Christian Taulien of Strange Intelligence
  755. *
  756. * Datum:  4. Juni 1997
  757. *
  758. * Letzte Änderungen/Neuerungen:
  759. *  4. Juni 1997:  Methode definiert
  760. *
  761. *************************************************************************/
  762. /*E*/
  763. {
  764. TRACEMETHOD
  765. ASSERT(checkInstance())
  766.   // the resize-size must be min 2 chars
  767.   ULONG ulSize = SIFC_MAX(arg_ulSize, 2);
  768.  
  769.   // save the buffer-pointer
  770.   char *sTemp = releaseBuffer();
  771.  
  772.   // now the old buffer can be freed if it is neccessary
  773.   if (sTemp)
  774.   {
  775.     // allocate a new buffer with the right size, but the old string
  776.     initStringC(sTemp, ulSize);
  777.     delete [] sTemp;
  778.   }
  779.   else
  780.   {
  781.     // get the new buffer by giving just the new size
  782.     initStringC(ulSize);
  783.   } // if (sTemp)
  784. }
  785. /*E*/
  786. ULONG StringC::getBufferSize(void) const
  787. /*S*/
  788. /*S*/ /* Methoden-Rahmen */
  789. /*************************************************************************
  790. * Name der Methode: getBufferSize()
  791. *
  792. * Klasse: StringC
  793. *
  794. * Funktion: Ermittelt die Größe des Buffers
  795. *
  796. * Zugriff: protected
  797. *
  798. * Eingabe-Parameter: -
  799. *
  800. * Ausgabe-Parameter: ULONG: Die Größe des Buffers
  801. *
  802. * Aufgerufen von: -
  803. *
  804. * Verwendung folgender globaler Variablen/Strukturen: -
  805. *
  806. * Benutzte Methoden: -
  807. *
  808. * Version: 1.1
  809. *
  810. * Autor: Christian Taulien of Strange Intelligence
  811. *
  812. * Datum:  1. April 1998
  813. *
  814. * Letzte Änderungen/Neuerungen:
  815. * 15. Oktober 1997: Methode definiert
  816. *    1. April 1998: Speichermanagement für StringArrayC angepasst.
  817. *
  818. *************************************************************************/
  819. /*E*/
  820. {
  821. TRACEMETHOD
  822. ASSERT(checkInstance())
  823.  
  824. return(m_poData->m_ulBufLen);
  825. }
  826. /*E*/
  827.  
  828. // public methods --------------------------------------------------
  829. // Constructors & Destruktor
  830. StringC::StringC()
  831. /*S*/
  832. /*S*/ /* Methoden-Rahmen */
  833. /*************************************************************************
  834. * Name der Methode: StringC()
  835. *
  836. * Klasse: StringC
  837. *
  838. * Funktion: Konstruktor
  839. *
  840. * Zugriff: public
  841. *
  842. * Eingabe-Parameter: -
  843. *
  844. * Ausgabe-Parameter: -
  845. *
  846. * Aufgerufen von: -
  847. *
  848. * Verwendung folgender globaler Variablen/Strukturen: -
  849. *
  850. * Benutzte Methoden: 1
  851. *   initInstance()
  852. *
  853. * Version: 1.1
  854. *
  855. * Autor: Christian Taulien of Strange Intelligence
  856. *
  857. * Datum:  2. März 1998
  858. *
  859. * Letzte Änderungen/Neuerungen:
  860. * 15. Oktober 1997: Methode definiert
  861. *  2. März 1998: Fehler in den debug-infos berichtigt
  862. *
  863. *************************************************************************/
  864. /*E*/
  865. {
  866. TRACEMETHOD
  867.   initInstance();
  868. }
  869. /*E*/
  870. StringC::StringC(const char *arg_sStrPtr)
  871. /*S*/
  872. /*S*/ /* Methoden-Rahmen */
  873. /*************************************************************************
  874. * Name der Methode: StringC()
  875. *
  876. * Klasse: StringC
  877. *
  878. * Funktion: Konstruktor mit const char-Pointer als Argument
  879. *
  880. * Zugriff: public
  881. *
  882. * Eingabe-Parameter: 1
  883. *   arg_sStrPtr:  Zeiger auf eine Zeichenkette oder NULL
  884. *
  885. * Ausgabe-Parameter: -
  886. *
  887. * Aufgerufen von: -
  888. *
  889. * Verwendung folgender globaler Variablen/Strukturen: -
  890. *
  891. * Benutzte Methoden: 2
  892. *   initString()
  893. *   intiInstance()
  894. *
  895. * Version: 1.1
  896. *
  897. * Autor: Christian Taulien of Strange Intelligence
  898. *
  899. * Datum:  2. März 1998
  900. *
  901. * Letzte Änderungen/Neuerungen:
  902. * 15. Oktober 1997: Methode definiert
  903. *  2. März 1998: Fehler in den Debuginfos berichtigt
  904. *
  905. *************************************************************************/
  906. /*E*/
  907. {
  908. TRACEMETHOD
  909.   // if we got a non-zero-pointer
  910.   if (arg_sStrPtr)
  911.   {
  912.     initStringC(arg_sStrPtr, strlen(arg_sStrPtr));
  913.   }
  914.   else
  915.   {
  916.     // otherwise default init
  917.     initInstance();
  918.   } // if
  919. }
  920. /*E*/
  921. StringC::StringC(ULONG  arg_ulBufLen)
  922. /*S*/
  923. /*S*/ /* Methoden-Rahmen */
  924. /*************************************************************************
  925. * Name der Methode: StringC()
  926. *
  927. * Klasse: StringC
  928. *
  929. * Funktion: Konstruktor mit Bufferlängenangabe
  930. *
  931. * Zugriff: public
  932. *
  933. * Eingabe-Parameter: 1
  934. *   arg_ulBufLen:   Gewünschte Länge des StringBuffers
  935. *
  936. * Ausgabe-Parameter: -
  937. *
  938. * Aufgerufen von: -
  939. *
  940. * Verwendung folgender globaler Variablen/Strukturen: -
  941. *
  942. * Benutzte Methoden: 1
  943. *   initString()
  944. *
  945. * Version: 1.1
  946. *
  947. * Autor: Christian Taulien of Strange Intelligence
  948. *
  949. * Datum:  2. März 1998
  950. *
  951. * Letzte Änderungen/Neuerungen:
  952. * 15. Oktober 1997: Methode definiert
  953. *  2. März 1998: Fehler in den Debuginfos berichtigt
  954. *
  955. *************************************************************************/
  956. /*E*/
  957. {
  958. TRACEMETHOD
  959.   // if the buflen is non-zero
  960.   if (arg_ulBufLen)
  961.   {
  962.     initStringC(arg_ulBufLen);
  963.   }
  964.   else
  965.   {
  966.     // otherwise default way
  967.     initInstance();
  968.   } // if
  969. }
  970. /*E*/
  971. StringC::StringC(const char *arg_sStrPtr, ULONG arg_ulBufLen)
  972. /*S*/
  973. /*S*/ /* Methoden-Rahmen */
  974. /*************************************************************************
  975. * Name der Methode: StringC()
  976. *
  977. * Klasse: StringC
  978. *
  979. * Funktion: Konstruktor mit Zeichenketten- und Bufferlängenangabe
  980. *
  981. * Zugriff: public
  982. *
  983. * Eingabe-Parameter: 2
  984. *   arg_sStrPtr: Zeiger auf den Init-string
  985. *   arg_ulBufLen:   Gewünschte Länge des StringBuffers
  986. *
  987. * Ausgabe-Parameter: -
  988. *
  989. * Aufgerufen von: -
  990. *
  991. * Verwendung folgender globaler Variablen/Strukturen: -
  992. *
  993. * Benutzte Methoden: 2
  994. *   initString()
  995. *   initInstance()
  996. *
  997. * Version: 1.1
  998. *
  999. * Autor: Christian Taulien of Strange Intelligence
  1000. *
  1001. * Datum:  2. März 1998
  1002. *
  1003. * Letzte Änderungen/Neuerungen:
  1004. * 15. Oktober 1997: Methode definiert
  1005. *  2. März 1998: Fehler in den Debuginfos berichtigt
  1006. *
  1007. *************************************************************************/
  1008. /*E*/
  1009. {
  1010. TRACEMETHOD
  1011.   // if we got a non-zero string pointer at all
  1012.   if (arg_sStrPtr)
  1013.   {
  1014.     // ok - ready to init
  1015.     initStringC(arg_sStrPtr, arg_ulBufLen);
  1016.   }
  1017.   else
  1018.   {
  1019.     // but if we got a non-zero buflen
  1020.     if (arg_ulBufLen)
  1021.     {
  1022.       // init by buflen
  1023.       initStringC(arg_ulBufLen);
  1024.     }
  1025.     else
  1026.     {
  1027.       // init the object in a default way
  1028.       initInstance();
  1029.     } // if
  1030.   } // if
  1031. }
  1032. /*E*/
  1033. StringC::StringC(const StringC &arg_roSrcObj)
  1034. /*S*/
  1035. /*S*/ /* Methoden-Rahmen */
  1036. /*************************************************************************
  1037. * Name der Methode: StringC()
  1038. *
  1039. * Klasse: StringC
  1040. *
  1041. * Funktion: Kopier-Konstruktor
  1042. *
  1043. * Zugriff: public
  1044. *
  1045. * Eingabe-Parameter: 1
  1046. *   arg_roSrcObj:   Referenz auf ein Quell-objekt
  1047. *
  1048. * Ausgabe-Parameter: -
  1049. *
  1050. * Aufgerufen von: -
  1051. *
  1052. * Verwendung folgender globaler Variablen/Strukturen: -
  1053. *
  1054. * Benutzte Methoden: 1
  1055. *   initString()
  1056. *
  1057. * Version: 1.1
  1058. *
  1059. * Autor: Christian Taulien of Strange Intelligence
  1060. *
  1061. * Datum:  2. März 1998
  1062. *
  1063. * Letzte Änderungen/Neuerungen:
  1064. * 15. Oktober 1997: Methode definiert
  1065. *  2. März 1998: Fehler in den Debuginfos berichtigt
  1066. *
  1067. *************************************************************************/
  1068. /*E*/
  1069. {
  1070. TRACEMETHOD
  1071. ASSERT(arg_roSrcObj.checkInstance());
  1072.   // copy the datapointer
  1073.   m_poData = arg_roSrcObj.m_poData;
  1074.  
  1075.   // and increase the reference counter
  1076.   incReference();
  1077. }
  1078. /*E*/
  1079. StringC::~StringC()
  1080. /*S*/
  1081. /*S*/ /* Methoden-Rahmen */
  1082. /*************************************************************************
  1083. * Name der Methode: ~StringC()
  1084. *
  1085. * Klasse: StringC
  1086. *
  1087. * Funktion: Destruktor
  1088. *
  1089. * Zugriff: public
  1090. *
  1091. * Eingabe-Parameter: -
  1092. *
  1093. * Ausgabe-Parameter: -
  1094. *
  1095. * Aufgerufen von: -
  1096. *
  1097. * Verwendung folgender globaler Variablen/Strukturen: -
  1098. *
  1099. * Benutzte Methoden: 1
  1100. *   freeBuffer()
  1101. *
  1102. * Version: 1.0
  1103. *
  1104. * Autor: Christian Taulien of Strange Intelligence
  1105. *
  1106. * Datum: 15. Oktober 1997
  1107. *
  1108. * Letzte Änderungen/Neuerungen:
  1109. * 15. Oktober 1997: Methode definiert
  1110. *
  1111. *************************************************************************/
  1112. /*E*/
  1113. {
  1114. TRACEMETHOD
  1115.   freeBuffer();
  1116. }
  1117. /*E*/
  1118. // CVI-Methods
  1119. BOOL StringC::checkInstance(void) const
  1120. /*S*/
  1121. /*S*/ /* Methoden-Rahmen */
  1122. /*************************************************************************
  1123. * Name der Methode: checkInstance()
  1124. *
  1125. * Klasse: StringC
  1126. *
  1127. * Funktion: prüft, ob die Objekt-Instanz gültig ist
  1128. *
  1129. * Zugriff: public
  1130. *
  1131. * Eingabe-Parameter: -
  1132. *
  1133. * Ausgabe-Parameter: -
  1134. *
  1135. * Aufgerufen von: -
  1136. *
  1137. * Verwendung folgender globaler Variablen/Strukturen: 1
  1138. *   global_sEmptyString: der globale EmptryString
  1139. *
  1140. * Benutzte Methoden: -
  1141. *
  1142. * Version: 1.1
  1143. *
  1144. * Autor: Christian Taulien of Strange Intelligence
  1145. *
  1146. * Datum:  1. April 1998
  1147. *
  1148. * Letzte Änderungen/Neuerungen:
  1149. *   11. Juni 1997:  Methode definiert
  1150. *    1. April 1998: Speichermanagement für StringArrayC angepasst.
  1151. *
  1152. *************************************************************************/
  1153. /*E*/
  1154. {
  1155. TRACEMETHOD
  1156.   // worst case at all:
  1157.   if (!m_poData)
  1158.   {
  1159.     printf("!m_poData\n");
  1160.     return FALSE;
  1161.   } // if
  1162.  
  1163.   // At no time, it is valid to have a zero-stringpointer
  1164.   if (!m_poData->m_sStrPtr)
  1165.   {
  1166.     printf("!m_poData->m_sStrPtr\n");
  1167.     return(FALSE);
  1168.   } // if (!m_sStrPtr)
  1169.  
  1170.   // our StrLen can't be greater than our BufLen
  1171.   if (m_poData->m_ulStrLen > m_poData->m_ulBufLen)
  1172.   {
  1173.     printf("m_poData->m_ulStrLen > m_poData->m_ulBufLen\n");
  1174.     return(FALSE);
  1175.   } // if (m_ulStrLen > m_ulBufLen)
  1176.  
  1177.   // if we got no BufLen, we can't have got a StrLen
  1178.   if (m_poData->m_ulStrLen && (!m_poData->m_ulBufLen))
  1179.   {
  1180.     printf("m_poData->m_ulStrLen && (!m_poData->m_ulBufLen)\n");
  1181.     return(FALSE);
  1182.   } // if (m_ulStrLen && (!m_ulBufLen))
  1183.  
  1184.   // if our string is not zero-byted
  1185.   if (m_poData->m_sStrPtr[m_poData->m_ulStrLen]!=0)
  1186.   {
  1187.     printf("m_poData->m_sStrPtr[m_poData->m_ulStrLen]!=0\n");
  1188.     return(FALSE);
  1189.   } // if (m_sStrPtr[m_ulStrLen]!=0)
  1190.  
  1191. // if we reached this point, we are valid
  1192. return(TRUE);
  1193. }
  1194. /*E*/
  1195. void StringC::validateInstance(void)
  1196. /*S*/
  1197. /*S*/ /* Methoden-Rahmen */
  1198. /*************************************************************************
  1199. * Name der Methode: validateInstance()
  1200. *
  1201. * Klasse: StringC
  1202. *
  1203. * Funktion: Überprüft die Objektinstanz und korrigiert es gegebenenfalls
  1204. *
  1205. * Zugriff: public
  1206. *
  1207. * Eingabe-Parameter: -
  1208. *
  1209. * Ausgabe-Parameter: -
  1210. *
  1211. * Aufgerufen von: -
  1212. *
  1213. * Verwendung folgender globaler Variablen/Strukturen: -
  1214. *
  1215. * Benutzte Methoden: 2
  1216. *   initInstance()
  1217. *   string.h/strlen()
  1218. *
  1219. * Version: 1.1
  1220. *
  1221. * Autor: Christian Taulien of Strange Intelligence
  1222. *
  1223. * Datum:  1. April 1998
  1224. *
  1225. * Letzte Änderungen/Neuerungen:
  1226. *   11. Juni 1997:  Methode definiert
  1227. *    1. April 1998: Speichermanagement für StringArrayC angepasst.
  1228. *
  1229. *************************************************************************/
  1230. /*E*/
  1231. {
  1232. TRACEMETHOD
  1233.   // if we have an invalid string pointer
  1234.   if (!m_poData->m_sStrPtr)
  1235.   {
  1236.     // initialize the object
  1237.     initInstance();
  1238.   }
  1239.   else
  1240.   {
  1241.     // if buf is valid and no empty string
  1242.     if (m_poData->m_ulBufLen)
  1243.     {
  1244.       // there has to be a zero-byte
  1245.       m_poData->m_sStrPtr[m_poData->m_ulBufLen]=0;
  1246.       // compute the real string-length
  1247.       m_poData->m_ulStrLen=strlen(m_poData->m_sStrPtr);
  1248.     } // if (m_ulBufLen)
  1249.  
  1250.     // if
  1251.     if (m_poData->m_lRefs < 1)
  1252.     {     
  1253.       m_poData->m_lRefs = 1;
  1254.     } // if
  1255.   } // if (!m_sStrPtr)
  1256. }
  1257. /*E*/
  1258. void StringC::initInstance(void)
  1259. /*S*/
  1260. /*S*/ /* Methoden-Rahmen */
  1261. /*************************************************************************
  1262. * Name der Methode: initInstance()
  1263. *
  1264. * Klasse: StringC
  1265. *
  1266. * Funktion: Initialisiert die StringC-Instanz
  1267. *
  1268. * Zugriff: public
  1269. *
  1270. * Eingabe-Parameter: -
  1271. *
  1272. * Ausgabe-Parameter: -
  1273. *
  1274. * Aufgerufen von:
  1275. *
  1276. * Verwendung folgender globaler Variablen/Strukturen: 1
  1277. *   global_sEmtpyString - Zeiger auf eine leere Zeichenkette
  1278. *
  1279. * Benutzte Methoden: -
  1280. *
  1281. * Version: 1.1
  1282. *
  1283. * Autor: Christian Taulien of Strange Intelligence
  1284. *
  1285. * Datum:  1. April 1998
  1286. *
  1287. * Letzte Änderungen/Neuerungen:
  1288. *   27. Mai 1997:   Methode definiert
  1289. *    1. April 1998: Speichermanagement für StringArrayC angepasst.
  1290. *
  1291. *************************************************************************/
  1292. /*E*/
  1293. {
  1294. TRACEMETHOD
  1295.   // Assign the global empty string to the object
  1296.   m_poData = &glob_oEmptyStringData;
  1297. }
  1298. /*E*/
  1299.  
  1300. // static methods
  1301. void StringC::initStatic(StringC *arg_poString)
  1302. /*S*/
  1303. /*S*/ /* Methoden-Rahmen */
  1304. /*************************************************************************
  1305. * Name der Methode:
  1306. *
  1307. * Klasse:
  1308. *
  1309. * Funktion:
  1310. *
  1311. * Zugriff:
  1312. *
  1313. * Eingabe-Parameter:
  1314. *
  1315. * Ausgabe-Parameter:
  1316. *
  1317. * Aufgerufen von:
  1318. *
  1319. * Verwendung folgender globaler Variablen/Strukturen:
  1320. *
  1321. * Benutzte Methoden:
  1322. *
  1323. * Version: 1.0
  1324. *
  1325. * Autor: Christian Taulien of Strange Intelligence
  1326. *
  1327. * Datum: 15. April 1998
  1328. *
  1329. * Letzte Änderungen/Neuerungen:
  1330. * 15. April 1998: Methode definiert
  1331. *
  1332. *************************************************************************/
  1333. /*E*/
  1334. {
  1335.   if (arg_poString)
  1336.   {
  1337.     arg_poString->m_poData = &glob_oEmptyStringData;
  1338.   } // if
  1339. }
  1340. /*E*/
  1341.  
  1342. // other public methods
  1343. BOOL StringC::isEmpty(void) const
  1344. /*S*/
  1345. /*S*/ /* Methoden-Rahmen */
  1346. /*************************************************************************
  1347. * Name der Methode: isEmpty()
  1348. *
  1349. * Klasse: StringC
  1350. *
  1351. * Funktion: Prüft, ob das Objekt eine Leere Zeichenkette repräsentiert
  1352. *
  1353. * Zugriff: public
  1354. *
  1355. * Eingabe-Parameter: -
  1356. *
  1357. * Ausgabe-Parameter: BOOL: TRUE, wenn der String leer ist (Länge=0)
  1358. *
  1359. * Aufgerufen von: -
  1360. *
  1361. * Verwendung folgender globaler Variablen/Strukturen: -
  1362. *
  1363. * Benutzte Methoden: -
  1364. *
  1365. * Version: 1.2
  1366. *
  1367. * Autor: Christian Taulien of Strange Intelligence
  1368. *
  1369. * Datum:  1. April 1998
  1370. *
  1371. * Letzte Änderungen/Neuerungen:
  1372. * 15. Oktober 1997: Methode definiert
  1373. *  2. März 1998:    Fehler in den Debuginfos berichtigt
  1374. *    1. April 1998: Speichermanagement für StringArrayC angepasst.
  1375. *
  1376. *************************************************************************/
  1377. /*E*/
  1378. {
  1379. TRACEMETHOD
  1380. ASSERT(checkInstance())
  1381. return m_poData->m_ulStrLen ? FALSE : TRUE;
  1382. }
  1383. /*E*/
  1384. void StringC::emptyString(void)
  1385. /*S*/
  1386. /*S*/ /* Methoden-Rahmen */
  1387. /*************************************************************************
  1388. * Name der Methode: emptyString()
  1389. *
  1390. * Klasse: StringC
  1391. *
  1392. * Funktion: Leert den String. D.h. setzt einen Leerstring.
  1393. *
  1394. * Zugriff: public
  1395. *
  1396. * Eingabe-Parameter: -
  1397. *
  1398. * Ausgabe-Parameter: -
  1399. *
  1400. * Aufgerufen von: -
  1401. *
  1402. * Verwendung folgender globaler Variablen/Strukturen: -
  1403. *
  1404. * Benutzte Methoden: 1
  1405. *   freeBuffer()
  1406. *
  1407. * Version: 1.1
  1408. *
  1409. * Autor: Christian Taulien of Strange Intelligence
  1410. *
  1411. * Datum:  2. März 1998
  1412. *
  1413. * Letzte Änderungen/Neuerungen:
  1414. * 15. Oktober 1997: Methode definiert
  1415. *  2. März 1998: Fehler in den Debuginfos berichtigt
  1416. *
  1417. *************************************************************************/
  1418. /*E*/
  1419. {
  1420. TRACEMETHOD
  1421.   freeBuffer();
  1422. }
  1423. /*E*/
  1424. ULONG StringC::getLength(void) const
  1425. /*S*/
  1426. /*S*/ /* Methoden-Rahmen */
  1427. /*************************************************************************
  1428. * Name der Methode: getLength()
  1429. *
  1430. * Klasse: StringC
  1431. *
  1432. * Funktion: Ermittelt die Länge des Strings
  1433. *
  1434. * Zugriff: public
  1435. *
  1436. * Eingabe-Parameter: -
  1437. *
  1438. * Ausgabe-Parameter: ULONG: Die Länge des Strings
  1439. *
  1440. * Aufgerufen von: -
  1441. *
  1442. * Verwendung folgender globaler Variablen/Strukturen: -
  1443. *
  1444. * Benutzte Methoden: -
  1445. *
  1446. * Version: 1.2
  1447. *
  1448. * Autor: Christian Taulien of Strange Intelligence
  1449. *
  1450. * Datum:  1. April 1998
  1451. *
  1452. * Letzte Änderungen/Neuerungen:
  1453. * 15. Oktober 1997: Methode definiert
  1454. *  2. März 1998: Fehler in den Debuginfos berichtigt
  1455. *  1. April 1998: Speichermanagement für StringArrayC angepasst.
  1456. *
  1457. *************************************************************************/
  1458. /*E*/
  1459. {
  1460. TRACEMETHOD
  1461. ASSERT(checkInstance());
  1462.  
  1463. return m_poData->m_ulStrLen;
  1464. }
  1465. /*E*/
  1466. const char *StringC::getBuffer(void) const
  1467. /*S*/
  1468. /*S*/ /* Methoden-Rahmen */
  1469. /*************************************************************************
  1470. * Name der Methode: getBuffer()
  1471. *
  1472. * Klasse: StringC
  1473. *
  1474. * Funktion: Ermittelt einen Zeiger auf den String als char *
  1475. *
  1476. * Zugriff: public
  1477. *
  1478. * Eingabe-Parameter: -
  1479. *
  1480. * Ausgabe-Parameter: const char *: Der Zeicher auf die Zeichenkette
  1481. *
  1482. * Aufgerufen von: -
  1483. *
  1484. * Verwendung folgender globaler Variablen/Strukturen: -
  1485. *
  1486. * Benutzte Methoden: -
  1487. *
  1488. * Version: 1.2
  1489. *
  1490. * Autor: Christian Taulien of Strange Intelligence
  1491. *
  1492. * Datum:  1. April 1998
  1493. *
  1494. * Letzte Änderungen/Neuerungen:
  1495. * 15. Oktober 1997: Methode definiert
  1496. * 28. Februar 1998: Fehler in der debug-info berichtigt.
  1497. *    1. April 1998: Speichermanagement für StringArrayC angepasst.
  1498. *
  1499. *************************************************************************/
  1500. /*E*/
  1501. {
  1502. TRACEMETHOD
  1503. ASSERT(checkInstance())
  1504. return m_poData->m_sStrPtr;
  1505. }
  1506. /*E*/
  1507. void StringC::freeExtra(void)
  1508. /*S*/
  1509. /*S*/ /* Methoden-Rahmen */
  1510. /*************************************************************************
  1511. * Name der Methode: freeExtra()
  1512. *
  1513. * Klasse: StringC
  1514. *
  1515. * Funktion: Minimiert den Speicherverbrauch. (Aber: Fragmentierung!)
  1516. *
  1517. * Zugriff: public
  1518. *
  1519. * Eingabe-Parameter: -
  1520. *
  1521. * Ausgabe-Parameter: -
  1522. *
  1523. * Aufgerufen von: -
  1524. *
  1525. * Verwendung folgender globaler Variablen/Strukturen: -
  1526. *
  1527. * Benutzte Methoden: 1
  1528. *   resizeBuffer()
  1529. *
  1530. * Version: 1.1
  1531. *
  1532. * Autor: Christian Taulien of Strange Intelligence
  1533. *
  1534. * Datum:  2. März 1998
  1535. *
  1536. * Letzte Änderungen/Neuerungen:
  1537. * 15. Oktober 1997: Methode definiert
  1538. *  2. März 1998: Fehler in den Debuginfos berichtigt
  1539. *
  1540. *************************************************************************/
  1541. /*E*/
  1542. {
  1543. TRACEMETHOD
  1544. ASSERT(checkInstance())
  1545.   // prepareModify() is not nessecary, because
  1546.   // releaseBuffer() called by resizeBuffer() will
  1547.   // do this for us.
  1548.   resizeBuffer(strlen(m_poData->m_sStrPtr));
  1549. }
  1550. /*E*/
  1551. char StringC::getAt(ULONG arg_ulIndex, BOOL arg_fResizeIfNeccessary /*=FALSE*/)
  1552. /*S*/
  1553. /*S*/ /* Methoden-Rahmen */
  1554. /*************************************************************************
  1555. * Name der Methode: getAt()
  1556. *
  1557. * Klasse: StringC
  1558. *
  1559. * Funktion: Ermittelt das n.te Zeichen des Strings
  1560. *
  1561. * Zugriff: public
  1562. *
  1563. * Eingabe-Parameter: 2
  1564. *   ULONG arg_ulIndex: Das wievielte Zeichen ermittelt werden soll
  1565. *   BOOL arg_fResizeIfNeccessary: (optional, def=FALSE) TRUE, wenn der Buffer
  1566. *     vergrößert werden soll, wenn außerhalb des Buffers zugegriffen wird
  1567. *
  1568. * Ausgabe-Parameter: char: Das an der n.ten Stelle stehende Zeichen
  1569. *
  1570. * Aufgerufen von: -
  1571. *
  1572. * Verwendung folgender globaler Variablen/Strukturen: -
  1573. *
  1574. * Benutzte Methoden: 3
  1575. *   ObjectXC::ObjectXC()
  1576. *   getStringTableEntry()
  1577. *   resizeBuffer()
  1578. *
  1579. * Version: 1.1
  1580. *
  1581. * Autor: Christian Taulien of Strange Intelligence
  1582. *
  1583. * Datum: 29. Juni 1997
  1584. *
  1585. * Letzte Änderungen/Neuerungen:
  1586. *  4. Juni 1997:  Methode definiert
  1587. *   29. Juni 1997:  Wenn versucht wird auch außerhalb der String-Länge
  1588. *           zuzugreifen, wird lediglich eine NULL zurückgegeben.
  1589. *
  1590. *************************************************************************/
  1591. /*E*/
  1592. {
  1593. TRACEMETHOD
  1594. ASSERT(checkInstance())
  1595. ASSERT(arg_ulIndex < getBufferSize())
  1596.  
  1597.   // if the access is out of allocated range
  1598.   if (arg_ulIndex > getBufferSize())
  1599.   {
  1600.     // and if no Resizing is wanted
  1601.     if (!arg_fResizeIfNeccessary)
  1602.     {
  1603.       // we have to throw a stone, okay not really but nearly
  1604.       ASSERT(FALSE);
  1605.       arg_ulIndex = NULL;
  1606.     }
  1607.     else
  1608.     {
  1609.       // reallocate memory
  1610.       resizeBuffer(arg_ulIndex);
  1611.     } // if (!arg_fResizeIfNeccessary)
  1612.   } // if (arg_ulIndex >= m_ulBufLen)
  1613.  
  1614.   // if we try to access out of the string length
  1615.   if (arg_ulIndex >= m_poData->m_ulStrLen)
  1616.   {
  1617.     // just return zero
  1618.     return(NULL);
  1619.   } // if (arg_ulIndex >= m_ulStrLen)
  1620.  
  1621. return(m_poData->m_sStrPtr[arg_ulIndex]);
  1622. }
  1623. /*E*/
  1624. char *StringC::releaseBuffer(void)
  1625. /*S*/
  1626. /*S*/ /* Methoden-Rahmen */
  1627. /*************************************************************************
  1628. * Name der Methode: releaseBuffer()
  1629. *
  1630. * Klasse: StringC
  1631. *
  1632. * Funktion: gibt die Verwaltung des Buffers an andere frei
  1633. *
  1634. * Zugriff: public
  1635. *
  1636. * Eingabe-Parameter: -
  1637. *
  1638. * Ausgabe-Parameter: char *: Zeiger auf den Buffer
  1639. *
  1640. * Aufgerufen von: -
  1641. *
  1642. * Verwendung folgender globaler Variablen/Strukturen: -
  1643. *
  1644. * Benutzte Methoden: 1
  1645. *   initInstance()
  1646. *
  1647. * Version: 1.0
  1648. *
  1649. * Autor: Christian Taulien of Strange Intelligence
  1650. *
  1651. * Datum:  4. Juni 1997
  1652. *
  1653. * Letzte Änderungen/Neuerungen:
  1654. *  4. Juni 1997:  Methode definiert
  1655. *
  1656. *************************************************************************/
  1657. /*E*/
  1658. {
  1659. TRACEMETHOD
  1660. ASSERT(checkInstance());
  1661.  
  1662.   // safety - check
  1663.   if (!getBufferSize())
  1664.   {
  1665.      return(NULL);
  1666.   } // if (!m_ulBufLen)
  1667.  
  1668.   // den Buffermodus auf jeden fall jetzt umschalten
  1669.   prepareModify();
  1670.  
  1671.   // save pointer to the string
  1672.   char *sTemp = m_poData->m_sStrPtr;
  1673.  
  1674.   // re-init the object without freeing our mem (because we'll need it later)
  1675.   initInstance();
  1676.  
  1677. // return the pointer to the mem, now its left to the caller to free the mem
  1678. return(sTemp);
  1679. }
  1680. /*E*/
  1681. char StringC::setAt(ULONG arg_ulIndex, char arg_cChar, BOOL arg_fResizeIfNeccessary /*=FALSE*/)
  1682. /*S*/
  1683. /*S*/ /* Methoden-Rahmen */
  1684. /*************************************************************************
  1685. * Name der Methode: setAt()
  1686. *
  1687. * Klasse: StringC
  1688. *
  1689. * Funktion: setzt das n.te byte und gibt das alte zurück
  1690. *
  1691. * Zugriff: public
  1692. *
  1693. * Eingabe-Parameter: 3
  1694. *   ULONG arg_ulIndex: das wievielte byte bearbeitet werden soll
  1695. *   char arg_cChar: Dieses Byte wird an n.ter Stelle eingetragen
  1696. *   BOOL arg_fResizeIfNeccessary: (optional, def=FALSE) TRUE, wenn der Buffer
  1697. *     vergrößert werden soll, wenn außerhalb des Buffers zugegriffen wird
  1698. *
  1699. * Ausgabe-Parameter: char: das Zeichen, welches sich vorher an der stelle
  1700. *     befand
  1701. *
  1702. * Aufgerufen von: -
  1703. *
  1704. * Verwendung folgender globaler Variablen/Strukturen: -
  1705. *
  1706. * Benutzte Methoden: 3
  1707. *   ObjectXC::ObjectXC()
  1708. *   getStringTableEntry()
  1709. *   resizeBuffer()
  1710. *
  1711. * Version: 1.1
  1712. *
  1713. * Autor: Christian Taulien of Strange Intelligence
  1714. *
  1715. * Datum: 29. Juni 1997
  1716. *
  1717. * Letzte Änderungen/Neuerungen:
  1718. *  4. Juni 1997:  Methode definiert
  1719. *   29. Juni 1997:  Zugriffe sind nur noch vor und am String-Ende erlaubt
  1720. *           Zugriffe hinter dem Zero-Byte werden ignoriert.
  1721. *           Wenn das Zero-Byte indiziert wird, so wird nach
  1722. *           der Schreiboperation die Stringlänge erhöht und
  1723. *           das Zero-Byte auf der nächsten Position gesetzt.
  1724. *
  1725. *************************************************************************/
  1726. /*E*/
  1727. {
  1728. TRACEMETHOD
  1729. ASSERT(checkInstance())
  1730. // Access-Check (index should be smaller than buflen!)
  1731. ASSERT(arg_ulIndex < getBufferSize())
  1732.  
  1733.   char cOldChar = NULL;
  1734.   prepareModify();
  1735.  
  1736.   // if the access is out of allocated range
  1737.   if (arg_ulIndex >= getBufferSize())
  1738.   {
  1739.     // and if no resizing is wanted
  1740.     if (!arg_fResizeIfNeccessary)
  1741.     {
  1742.       ASSERT(FALSE);
  1743.       // we have to throw a stone
  1744.       throw STRINGC_XC;
  1745.     } // if (!arg_fResizeIfNeccessary)
  1746.  
  1747.     // reallocate memory
  1748.     resizeBuffer(arg_ulIndex);
  1749.   }
  1750.  
  1751.   // if the user accesses the "zero-byte"
  1752.   if (arg_ulIndex == getLength())
  1753.   {
  1754.     // if we do not write a zerobyte
  1755.     if (arg_cChar != NULL)
  1756.     {
  1757.       // set the new char
  1758.       m_poData->m_sStrPtr[arg_ulIndex] = arg_cChar;
  1759.       // increase the string length an guarantee the zero-byte exists
  1760.       m_poData->m_ulStrLen++;
  1761.       m_poData->m_sStrPtr[m_poData->m_ulStrLen] = '\0';
  1762.     } // if (arg_cChar != NULL)
  1763.   }
  1764.   else if (arg_ulIndex < getLength())
  1765.   {
  1766.     // otherwise we only allow accesses inner the string
  1767.     // outer-string accesses will be ignored
  1768.  
  1769.     // save the old char
  1770.     cOldChar = m_poData->m_sStrPtr[arg_ulIndex];
  1771.     // set the new char
  1772.     m_poData->m_sStrPtr[arg_ulIndex] = arg_cChar;
  1773.  
  1774.     // if we wrote a zerobyte
  1775.     if (arg_cChar == '\0')
  1776.     {
  1777.       // the given Index is the new string-length
  1778.       m_poData->m_ulStrLen = arg_ulIndex;
  1779.     } // if (arg_cChar == NULL)
  1780.   } // if (arg_ulIndex >= m_ulBufLen)
  1781.  
  1782.  
  1783. // return the old char
  1784. return(cOldChar);
  1785. }
  1786. /*E*/
  1787. void StringC::setString(const char *arg_sString)
  1788. /*S*/
  1789. /*S*/ /* Methoden-Rahmen */
  1790. /*************************************************************************
  1791. * Name der Methode: setString()
  1792. *
  1793. * Klasse: StringC
  1794. *
  1795. * Funktion: Zuweisungs-operator
  1796. *
  1797. * Zugriff: public
  1798. *
  1799. * Eingabe-Parameter: 1
  1800. *   arg_sString:  Ein Zeiger auf den neuen String
  1801. *
  1802. * Ausgabe-Parameter: -
  1803. *
  1804. * Aufgerufen von: -
  1805. *
  1806. * Verwendung folgender globaler Variablen/Strukturen: -
  1807. *
  1808. * Benutzte Methoden: 4
  1809. *   initInstance()
  1810. *   string.h/strlen()
  1811. *   allocBuffer()
  1812. *   string.h/strncpy()
  1813. *
  1814. * Version: 1.0
  1815. *
  1816. * Autor: Christian Taulien of Strange Intelligence
  1817. *
  1818. * Datum: 10. Oktober 1997
  1819. *
  1820. * Letzte Änderungen/Neuerungen:
  1821. * 10. Oktober 1997: Methode definiert
  1822. *
  1823. *************************************************************************/
  1824. /*E*/
  1825. {
  1826. TRACEMETHOD
  1827. ASSERT(checkInstance())
  1828.   // if we have got a zeropointer
  1829.   if (!arg_sString)
  1830.   {
  1831.     // default values
  1832.     initInstance();
  1833.   }
  1834.   else
  1835.   {
  1836.     // calculate the string-length
  1837.     int iLen = strlen(arg_sString);
  1838.  
  1839.     // allocate the required buffer
  1840.     // (no need for prepareModify())
  1841.     allocBuffer(iLen);
  1842.  
  1843.     // set the new length appropriately
  1844.     m_poData->m_ulStrLen = iLen;
  1845.  
  1846.     // copy the string
  1847.     strncpy(m_poData->m_sStrPtr, arg_sString, iLen);
  1848.  
  1849.     // put the zerobyte
  1850.     m_poData->m_sStrPtr[iLen] = 0;
  1851.   } // if
  1852. }
  1853. /*E*/
  1854. LONG StringC::compareStringNoCase(StringC &arg_roCompObj)
  1855. /*S*/
  1856. /*S*/ /* Methoden-Rahmen */
  1857. /*************************************************************************
  1858. * Name der Methode: compareStringNoCase()
  1859. *
  1860. * Klasse: StringC
  1861. *
  1862. * Funktion: vergleicht den String mit einem anderem ohne Beachtung der
  1863. *       Groß- und Kleinschreibung
  1864. *
  1865. * Zugriff: public
  1866. *
  1867. * Eingabe-Parameter: 1
  1868. *   StringC &arg_roCompObj: eine Referenz auf ein StringC-Object mit dem
  1869. *     dieses Obj. verglichen werden soll.
  1870. *
  1871. * Ausgabe-Parameter: LONG: >0 wenn this>arg, <0 wenn this<s, 0 wenn this==arg
  1872. *
  1873. * Aufgerufen von:
  1874. *
  1875. * Verwendung folgender globaler Variablen/Strukturen: keine
  1876. *
  1877. * Benutzte Methoden: 1
  1878. *   utility.library/Stricmp()
  1879. *
  1880. * Version: 1.3
  1881. *
  1882. * Autor: Christian Taulien of Strange Intelligence
  1883. *
  1884. * Datum: 12. Juni 1997
  1885. *
  1886. * Letzte Änderungen/Neuerungen:
  1887. *   20. November 1996:  Methode definiert
  1888. *   29. November 1996:  Exeptionhandling eingebaut
  1889. *  5. Dezember 1996:  Exeptionhandling wieder ausgebaut weil es Probleme
  1890. *             gab, als NodeC Objekte mit NULL-Pointern als Namen
  1891. *             z.B. sortiert werden sollten. Es gilt nun:
  1892. *             beide Op gleich NULL, Ergebnis 0 (für "wahr")
  1893. *             beide Op ungleich NULL, es entscheidet Stricmp()
  1894. *             der 1. Op gleich NULL, Ergebnis -1 für "<"
  1895. *             der 2. Op gleich NULL, Ergebnis 1 für ">"
  1896. *   12. Juni 1997   :   Aus dem Berlin-Projekt übernommen und angepasst
  1897. *             Aufgrund der StringC-Implementierung können
  1898. *             NULL-Zeiger nicht auftreten.
  1899. *
  1900. *************************************************************************/
  1901. /*E*/
  1902. {
  1903. TRACEMETHOD
  1904. ASSERT(checkInstance());
  1905. ASSERT(arg_roCompObj.checkInstance());
  1906.  
  1907. return(Stricmp(m_poData->m_sStrPtr, arg_roCompObj.m_poData->m_sStrPtr));
  1908. }
  1909. /*E*/
  1910. LONG StringC::compareStringNoCase(char *arg_sCompStr)
  1911. /*S*/
  1912. /*S*/ /* Methoden-Rahmen */
  1913. /*************************************************************************
  1914. * Name der Methode: compareStringNoCase()
  1915. *
  1916. * Klasse: StringC
  1917. *
  1918. * Funktion: Vergleicht den String mit einem anderem ohne Beachtung der
  1919. *       Groß- und Kleinschreibung
  1920. *
  1921. * Zugriff: public
  1922. *
  1923. * Eingabe-Parameter: 1
  1924. *   char *arg_sCompStr: ein Zeiger auf ein String mit dem
  1925. *     dieses Obj. verglichen werden soll.
  1926. *
  1927. * Ausgabe-Parameter: LONG: >0 wenn this>arg, <0 wenn this<s, 0 wenn this==arg
  1928. *
  1929. * Aufgerufen von:
  1930. *
  1931. * Verwendung folgender globaler Variablen/Strukturen: keine
  1932. *
  1933. * Benutzte Methoden: 1
  1934. *   utility.library/Stricmp()
  1935. *
  1936. * Version: 1.4
  1937. *
  1938. * Autor: Christian Taulien of Strange Intelligence
  1939. *
  1940. * Datum: 30. Juni 1997
  1941. *
  1942. * Letzte Änderungen/Neuerungen:
  1943. *   20. November 1996:  Methode definiert
  1944. *   29. November 1996:  Exeptionhandling eingebaut
  1945. *  5. Dezember 1996:  Exeptionhandling wieder ausgebaut weil es Probleme
  1946. *             gab, als NodeC Objekte mit NULL-Pointern als Namen
  1947. *             z.B. sortiert werden sollten. Es gilt nun:
  1948. *             beide Op gleich NULL, Ergebnis 0 (für "wahr")
  1949. *             beide Op ungleich NULL, es entscheidet Stricmp()
  1950. *             der 1. Op gleich NULL, Ergebnis -1 für "<"
  1951. *             der 2. Op gleich NULL, Ergebnis 1 für ">"
  1952. *   12. Juni 1997   :   Aus dem Berlin-Projekt übernommen und angepasst
  1953. *             Aufgrund der StringC-Implementierung können
  1954. *             NULL-Zeiger nicht auftreten.
  1955. *   30. Juni 1997:    Komplett von der gleichnamigen Methode mit StringC&
  1956. *             als Parameter übernommen
  1957. *
  1958. *************************************************************************/
  1959. /*E*/
  1960. {
  1961. TRACEMETHOD
  1962. ASSERT(checkInstance())
  1963. ASSERT(arg_sCompStr)
  1964.  
  1965. return(Stricmp(m_poData->m_sStrPtr, arg_sCompStr));
  1966. }
  1967. /*E*/
  1968. LONG StringC::compareStringLimited(StringC &arg_roCompObj, ULONG arg_ulLength)
  1969. /*S*/
  1970. /*S*/ /* Methoden-Rahmen */
  1971. /*************************************************************************
  1972. * Name der Methode: compareStringLimited()
  1973. *
  1974. * Klasse: StringC
  1975. *
  1976. * Funktion: Vergleicht den String mit einem Anderem mit Längenbegrenzung
  1977. *
  1978. * Zugriff: public
  1979. *
  1980. * Eingabe-Parameter: 2
  1981. *   StringC &arg_roCompObj: Eine Referenz eines StringC-Objektes mit dem verglichen
  1982. *         werden soll
  1983. *   ULONG arg_ulLength: Die maximale Anzahl der Bytes die beim Vergleich
  1984. *         berücksichtigt werden sollen.
  1985. *
  1986. * Ausgabe-Parameter: LONG: >0 wenn this>s, <0 wenn this<s, 0 wenn this==s
  1987. *
  1988. * Aufgerufen von:
  1989. *
  1990. * Verwendung folgender globaler Variablen/Strukturen: keine
  1991. *
  1992. * Benutzte Methoden: 1
  1993. *   string.h/strncmp()
  1994. *
  1995. * Version: 1.4
  1996. *
  1997. * Autor: Christian Taulien of Strange Intelligence
  1998. *
  1999. * Datum: 30. Juni 1997
  2000. *
  2001. * Letzte Änderungen/Neuerungen:
  2002. *   20. November 1996:  Methode definiert
  2003. *   29. November 1996:  Exeptionhandling eingebaut
  2004. *  5. Dezember 1996:  Exeptionhandling wieder ausgebaut weil es Probleme
  2005. *             gab, als NodeC Objekte mit NULL-Pointern als Namen
  2006. *             z.B. sortiert werden sollten. Es gilt nun:
  2007. *             beide Op gleich NULL, Ergebnis 0 (für "wahr")
  2008. *             beide Op ungleich NULL, es entscheidet Stricmp()
  2009. *             der 1. Op gleich NULL, Ergebnis -1 für "<"
  2010. *             der 2. Op gleich NULL, Ergebnis 1 für ">"
  2011. *   12. Juni 1997:    Aus dem Berlin-Projekt übernommen und angepasst
  2012. *             Aufgrund der StringC-Implementierung können
  2013. *             NULL-Pointer nicht auftreten. XC werden nur
  2014. *             bei Zugriff außerhalb der Range geworfen
  2015. *   30. Juni 1997:    Name des 2. Parameters berichtigt (l jetzt ul)
  2016. *             Es wird keine XC mehr geworfen, die Länge wird
  2017. *             automatisch auf die kleinere der beiden String-
  2018. *             Längen beschränkt.
  2019. *
  2020. *************************************************************************/
  2021. /*E*/
  2022. {
  2023. TRACEMETHOD
  2024. ASSERT(checkInstance())
  2025. ASSERT(arg_roCompObj.checkInstance())
  2026.   arg_ulLength = SIFC_MIN(arg_ulLength, getLength()+1);
  2027.   arg_ulLength = SIFC_MIN(arg_ulLength, arg_roCompObj.getLength()+1);
  2028.  
  2029. return(strncmp(m_poData->m_sStrPtr,arg_roCompObj.m_poData->m_sStrPtr, arg_ulLength));
  2030. }
  2031. /*E*/
  2032. LONG StringC::compareStringLimited(char *arg_sCompStr, ULONG arg_ulLength)
  2033. /*S*/
  2034. /*S*/ /* Methoden-Rahmen */
  2035. /*************************************************************************
  2036. * Name der Methode: compareStringLimited()
  2037. *
  2038. * Klasse: StringC
  2039. *
  2040. * Funktion: Vergleicht den String mit einem Anderem mit Längenbegrenzung
  2041. *
  2042. * Zugriff: public
  2043. *
  2044. * Eingabe-Parameter: 2
  2045. *   char *arg_sCompStr: Ein Zeiger auf einen String mit dem das Objekt
  2046. *        verglichen werden soll
  2047. *   ULONG arg_ulLength   : Die maximale Anzahl der Bytes die beim Vergleich
  2048. *         berücksichtigt werden sollen.
  2049. *
  2050. * Ausgabe-Parameter: LONG: >0 wenn this>s, <0 wenn this<s, 0 wenn this==s
  2051. *
  2052. * Aufgerufen von:
  2053. *
  2054. * Verwendung folgender globaler Variablen/Strukturen: keine
  2055. *
  2056. * Benutzte Methoden: 1
  2057. *   string.h/strncmp()
  2058. *
  2059. * Version: 1.4
  2060. *
  2061. * Autor: Christian Taulien of Strange Intelligence
  2062. *
  2063. * Datum: 30. Juni 1997
  2064. *
  2065. * Letzte Änderungen/Neuerungen:
  2066. *   20. November 1996:  Methode definiert
  2067. *   29. November 1996:  Exceptionhandling eingebaut
  2068. *  5. Dezember 1996:  Exceptionhandling wieder ausgebaut weil es Probleme
  2069. *             gab, als NodeC Objekte mit NULL-Pointern als Namen
  2070. *             z.B. sortiert werden sollten. Es gilt nun:
  2071. *             beide Op gleich NULL, Ergebnis 0 (für "wahr")
  2072. *             beide Op ungleich NULL, es entscheidet Stricmp()
  2073. *             der 1. Op gleich NULL, Ergebnis -1 für "<"
  2074. *             der 2. Op gleich NULL, Ergebnis 1 für ">"
  2075. *   12. Juni 1997:    Aus dem Berlin-Projekt übernommen und angepasst
  2076. *             Aufgrund der StringC-Implementierung können
  2077. *             NULL-Pointer nicht auftreten. XC werden nur
  2078. *             bei Zugriff außerhalb der Range geworfen
  2079. *   30. Juni 1997:    Es wird keine XC mehr geworfen, die Länge wird
  2080. *             automatisch auf die String-Länge beschränkt
  2081. *             Die Methode wurde von der gleichnamigen Version
  2082. *             die jedoch StringC& als 1. Parameter nimmt über-
  2083. *             nommen.
  2084. *
  2085. *************************************************************************/
  2086. /*E*/
  2087. {
  2088. TRACEMETHOD
  2089. ASSERT(checkInstance())
  2090. ASSERT(arg_sCompStr)
  2091.   arg_ulLength=SIFC_MIN(arg_ulLength,getLength()+1);
  2092.  
  2093. return(strncmp(m_poData->m_sStrPtr,arg_sCompStr, arg_ulLength));
  2094. }
  2095. /*E*/
  2096. LONG StringC::compareStringLimitedNoCase(StringC &arg_roCompObj, ULONG arg_ulLength)
  2097. /*S*/
  2098. /*S*/ /* Methoden-Rahmen */
  2099. /*************************************************************************
  2100. * Name der Methode: compareStringLimitedNoCase()
  2101. *
  2102. * Klasse: StringC
  2103. *
  2104. * Funktion: Vergleicht den String mit einem anderen mit Längenbegrenzung
  2105. *
  2106. * Zugriff: public
  2107. *
  2108. * Eingabe-Parameter: 2
  2109. *   StringC &arg_roCompObj: eine Referenz eines StringC-Objektes mit dem
  2110. *         verglichen werden soll
  2111. *   ULONG arg_ulLength: Die maximale Anzahl der Bytes die beim Vergleich
  2112. *         berücksichtigt werden sollen.
  2113. *
  2114. * Ausgabe-Parameter: LONG: >0 wenn this>s, <0 wenn this<s, 0 wenn this==s
  2115. *
  2116. * Aufgerufen von:
  2117. *
  2118. * Verwendung folgender globaler Variablen/Strukturen: keine
  2119. *
  2120. * Benutzte Methoden: 1
  2121. *   utility.library/Strnicmp()
  2122. *
  2123. * Version: 1.4
  2124. *
  2125. * Autor: Christian Taulien of Strange Intelligence
  2126. *
  2127. * Datum: 30. Juni 1997
  2128. *
  2129. * Letzte Änderungen/Neuerungen:
  2130. *   20. November 1996:  Methode definiert
  2131. *   29. November 1996:  Exeptionhandling eingebaut
  2132. *  5. Dezember 1996:  Exeptionhandling wieder ausgebaut weil es Probleme
  2133. *             gab, als NodeC Objekte mit NULL-Pointern als Namen
  2134. *             z.B. sortiert werden sollten. Es gilt nun:
  2135. *             beide Op gleich NULL, Ergebnis 0 (für "wahr")
  2136. *             beide Op ungleich NULL, es entscheidet Stricmp()
  2137. *             der 1. Op gleich NULL, Ergebnis -1 für "<"
  2138. *             der 2. Op gleich NULL, Ergebnis 1 für ">"
  2139. *   12. Juni 1997:    Aus dem Berlin-Projekt übernommen und angepasst
  2140. *   30. Juni 1997:    Es wird keine XC mehr geworfen. Die Vergleichs-
  2141. *             länge wird automatisch auf die kleinere der
  2142. *             beiden String-Längen beschränkt.
  2143. *
  2144. *************************************************************************/
  2145. /*E*/
  2146. {
  2147. TRACEMETHOD
  2148. ASSERT(checkInstance())
  2149. ASSERT(arg_roCompObj.checkInstance())
  2150.   arg_ulLength=SIFC_MIN(arg_ulLength,getLength()+1);
  2151.   arg_ulLength=SIFC_MIN(arg_ulLength,arg_roCompObj.getLength()+1);
  2152.  
  2153. return(Strnicmp(m_poData->m_sStrPtr,arg_roCompObj.m_poData->m_sStrPtr, arg_ulLength));
  2154. }
  2155. /*E*/
  2156. LONG StringC::compareStringLimitedNoCase(char *arg_sCompStr, ULONG arg_ulLength)
  2157. /*S*/
  2158. /*S*/ /* Methoden-Rahmen */
  2159. /*************************************************************************
  2160. * Name der Methode: compareStringLimitedNoCase()
  2161. *
  2162. * Klasse: StringC
  2163. *
  2164. * Funktion: Vergleicht den String mit einem anderen mit Längenbegrenzung
  2165. *
  2166. * Zugriff: public
  2167. *
  2168. * Eingabe-Parameter: 2
  2169. *   StringC &arg_sCompStr: ein Zeiger auf den String mit dem verglichen
  2170. *         werden soll
  2171. *   ULONG arg_ulLength   : Die maximale Anzahl der Bytes die beim Vergleich
  2172. *         berücksichtigt werden sollen.
  2173. *
  2174. * Ausgabe-Parameter: LONG: >0 wenn this>s, <0 wenn this<s, 0 wenn this==s
  2175. *
  2176. * Aufgerufen von:
  2177. *
  2178. * Verwendung folgender globaler Variablen/Strukturen: keine
  2179. *
  2180. * Benutzte Methoden: 1
  2181. *   utility.library/Strnicmp()
  2182. *
  2183. * Version: 1.4
  2184. *
  2185. * Autor: Christian Taulien of Strange Intelligence
  2186. *
  2187. * Datum: 30. Juni 1997
  2188. *
  2189. * Letzte Änderungen/Neuerungen:
  2190. *   20. November 1996:  Methode definiert
  2191. *   29. November 1996:  Exeptionhandling eingebaut
  2192. *  5. Dezember 1996:  Exeptionhandling wieder ausgebaut weil es Probleme
  2193. *             gab, als NodeC Objekte mit NULL-Pointern als Namen
  2194. *             z.B. sortiert werden sollten. Es gilt nun:
  2195. *             beide Op gleich NULL, Ergebnis 0 (für "wahr")
  2196. *             beide Op ungleich NULL, es entscheidet Stricmp()
  2197. *             der 1. Op gleich NULL, Ergebnis -1 für "<"
  2198. *             der 2. Op gleich NULL, Ergebnis 1 für ">"
  2199. *   12. Juni 1997:    Aus dem Berlin-Projekt übernommen und angepasst
  2200. *   30. Juni 1997:    Es wird keine XC mehr geworfen. Die Vergleichs-
  2201. *             länge wird automatisch auf die kleinere der
  2202. *             beiden String-Längen beschränkt.
  2203. *
  2204. *************************************************************************/
  2205. /*E*/
  2206. {
  2207. TRACEMETHOD
  2208. ASSERT(checkInstance())
  2209. ASSERT(arg_sCompStr)
  2210.   arg_ulLength=SIFC_MIN(arg_ulLength,getLength()+1);
  2211.  
  2212. return(Strnicmp(m_poData->m_sStrPtr,arg_sCompStr, arg_ulLength));
  2213. }
  2214. /*E*/
  2215. StringC StringC::midString(ULONG arg_ulFirst, ULONG arg_ulCount) const
  2216. /*S*/
  2217. /*S*/ /* Methoden-Rahmen */
  2218. /*************************************************************************
  2219. * Name der Methode: midString()
  2220. *
  2221. * Klasse: StringC
  2222. *
  2223. * Funktion: Pedant zur BASIC-Funktion MID$()
  2224. *
  2225. * Zugriff: public
  2226. *
  2227. * Eingabe-Parameter: 2
  2228. *   ULONG arg_ulFirst: 1. Zeichen das übernommen werden soll (index)
  2229. *   ULONG arg_ulCount: Anzahl der Zeichen
  2230. *
  2231. * Ausgabe-Parameter: Ein neues StringC-Objekt
  2232. *
  2233. * Aufgerufen von: -
  2234. *
  2235. * Verwendung folgender globaler Variablen/Strukturen: -
  2236. *
  2237. * Benutzte Methoden: 3
  2238. *   ObjectXC::ObjectXC()
  2239. *   getStringTableEntry()
  2240. *   StringC()
  2241. *
  2242. * Version: 1.2
  2243. *
  2244. * Autor: Christian Taulien of Strange Intelligence
  2245. *
  2246. * Datum:  6. August 1997
  2247. *
  2248. * Letzte Änderungen/Neuerungen:
  2249. *   13. Juni 1997:  Methode definiert
  2250. *   30. Juni 1997:  Die Methode prüft die Zugriffe jetzt stärker.
  2251. *           Bei einer Länge von NULL wird eine XC geworfen.
  2252. *           Die Länge muß kleiner oder gleich der restlichen
  2253. *           Bytes ab dem Index sein.
  2254. *   6. August 1997: Ist die Länge NULL, so wird keine XC mehr geworfen
  2255. *           Es wird nun ein leeres StringC-Objekt zurückgegeben.
  2256. *           was auch logischer ist. Außerdem wurde die Reihen-
  2257. *           folge der Prüfung verändert: Erst OutOfRange-Check
  2258. *           für das StartZeichen, dann Minimierung der Länge
  2259. *           Dann Prüfung auf Länge=NULL;
  2260. *
  2261. *************************************************************************/
  2262. /*E*/
  2263. {
  2264. TRACEMETHOD
  2265. ASSERT(checkInstance())
  2266. ASSERT(arg_ulCount)
  2267. ASSERT(arg_ulFirst+arg_ulCount <= getLength())
  2268.  
  2269.   // if the first char is already out of range
  2270.   if (arg_ulFirst >= getLength())
  2271.   {
  2272.     // we got to throw a stone
  2273.     throw STRINGC_XC;
  2274.   } // if
  2275.  
  2276.   // Minimize the Size of the destination string
  2277.   arg_ulCount=SIFC_MIN(arg_ulCount, getLength()-arg_ulFirst);
  2278.  
  2279.   // if the wanted stringlength is zero,
  2280.   if (!arg_ulCount)
  2281.   {
  2282.     // we return a zero-lengthened string
  2283.     return(StringC());
  2284.   } // if
  2285.  
  2286. return(StringC(m_poData->m_sStrPtr+arg_ulFirst, arg_ulCount));
  2287. }
  2288. /*E*/
  2289. StringC StringC::midString(ULONG arg_ulFirst) const
  2290. /*S*/
  2291. /*S*/ /* Methoden-Rahmen */
  2292. /*************************************************************************
  2293. * Name der Methode: midString()
  2294. *
  2295. * Klasse: StringC
  2296. *
  2297. * Funktion: Pedant zur BASIC-Funktion MID$()
  2298. *       Alles ab dem Index wird in einen neuen String übernommen
  2299. *
  2300. * Zugriff: public
  2301. *
  2302. * Eingabe-Parameter: 1
  2303. *   ULONG arg_ulFirst: 1. Zeichen das übernommen werden soll (index)
  2304. *
  2305. * Ausgabe-Parameter: Ein neues StringC-Objekt
  2306. *
  2307. * Aufgerufen von: -
  2308. *
  2309. * Verwendung folgender globaler Variablen/Strukturen: -
  2310. *
  2311. * Benutzte Methoden: 3
  2312. *   ObjectXC::ObjectXC()
  2313. *   getStringTableEntry()
  2314. *   StringC()
  2315. *
  2316. * Version: 1.1
  2317. *
  2318. * Autor: Christian Taulien of Strange Intelligence
  2319. *
  2320. * Datum: 30. Juni 1997
  2321. *
  2322. * Letzte Änderungen/Neuerungen:
  2323. *   13. Juni 1997:  Methode definiert
  2324. *   30. Juni 1997:  Die Methode kontrolliert den Zugriff schärfer
  2325. *           Für das Ergebnis wird ein sichererer Konstruktor ver-
  2326. *           wendet.
  2327. *
  2328. *************************************************************************/
  2329. /*E*/
  2330. {
  2331. TRACEMETHOD
  2332. ASSERT(checkInstance())
  2333. ASSERT(arg_ulFirst <= getLength())
  2334.  
  2335.   if (arg_ulFirst >= getLength())
  2336.   {
  2337.     throw STRINGC_XC;
  2338.   } // if
  2339. return(StringC(m_poData->m_sStrPtr+arg_ulFirst, getLength()-arg_ulFirst));
  2340. }
  2341. /*E*/
  2342. StringC StringC::leftString(ULONG arg_ulCount) const
  2343. /*S*/
  2344. /*S*/ /* Methoden-Rahmen */
  2345. /*************************************************************************
  2346. * Name der Methode: leftString()
  2347. *
  2348. * Klasse: StringC
  2349. *
  2350. * Funktion: Pedant zur BASIC-Funktion LEFT$()
  2351. *
  2352. * Zugriff: public
  2353. *
  2354. * Eingabe-Parameter: 1
  2355. *   ULONG arg_ulCount:  Anzahl der Zeichen von links
  2356. *
  2357. * Ausgabe-Parameter: Ein neues StringC-Objekt
  2358. *
  2359. * Aufgerufen von: -
  2360. *
  2361. * Verwendung folgender globaler Variablen/Strukturen: -
  2362. *
  2363. * Benutzte Methoden: 3
  2364. *   ObjectXC::ObjectXC()
  2365. *   getStringTableEntry()
  2366. *   StringC()
  2367. *
  2368. * Version: 1.1
  2369. *
  2370. * Autor: Christian Taulien of Strange Intelligence
  2371. *
  2372. * Datum: 30. Juni 1997
  2373. *
  2374. * Letzte Änderungen/Neuerungen:
  2375. *   13. Juni 1997:  Methode definiert
  2376. *   30. Juni 1997:  Eine Länge von NULL wird mit einer Exception geahndet
  2377. *
  2378. *************************************************************************/
  2379. /*E*/
  2380. {
  2381. TRACEMETHOD
  2382. ASSERT(checkInstance())
  2383. ASSERT(arg_ulCount <= getLength())
  2384.  
  2385.   if (!arg_ulCount || (arg_ulCount > getLength()))
  2386.   {
  2387.     throw STRINGC_XC;
  2388.   } // if
  2389. return(StringC(m_poData->m_sStrPtr, arg_ulCount));
  2390. }
  2391. /*E*/
  2392. StringC StringC::rightString(ULONG arg_ulCount) const
  2393. /*S*/
  2394. /*S*/ /* Methoden-Rahmen */
  2395. /*************************************************************************
  2396. * Name der Methode: rightString()
  2397. *
  2398. * Klasse: StringC
  2399. *
  2400. * Funktion: Pedant zur BASIC-Funktion RIGHT$()
  2401. *
  2402. * Zugriff: public
  2403. *
  2404. * Eingabe-Parameter: 1
  2405. *   ULONG arg_ulCount: Anzahl der Zeichen von rechts
  2406. *
  2407. * Ausgabe-Parameter: Ein neues StringC-Objekt
  2408. *
  2409. * Aufgerufen von: -
  2410. *
  2411. * Verwendung folgender globaler Variablen/Strukturen: -
  2412. *
  2413. * Benutzte Methoden: 3
  2414. *   ObjectXC::ObjectXC()
  2415. *   getStringTableEntry()
  2416. *   StringC()
  2417. *
  2418. * Version: 1.1
  2419. *
  2420. * Autor: Christian Taulien of Strange Intelligence
  2421. *
  2422. * Datum: 30. Juni 1997
  2423. *
  2424. * Letzte Änderungen/Neuerungen:
  2425. *   13. Juni 1997:  Methode definiert
  2426. *   30. Juni 1997:  Eine Länge von NULL wird mit einer Exception geahndet
  2427. *           Außerdem wird ein sichererer Konstruktor verwendet.
  2428. *
  2429. *************************************************************************/
  2430. /*E*/
  2431. {
  2432. TRACEMETHOD
  2433. ASSERT(checkInstance())
  2434. ASSERT(arg_ulCount <= getLength())
  2435.  
  2436.   if (!arg_ulCount || (arg_ulCount > getLength()))
  2437.   {
  2438.     throw STRINGC_XC;
  2439.   } // if
  2440. return(StringC(m_poData->m_sStrPtr+getLength()-arg_ulCount, arg_ulCount));
  2441. }
  2442. /*E*/
  2443. LONG StringC::findChar(char arg_cSearchedChar) const
  2444. /*S*/
  2445. /*S*/ /* Methoden-Rahmen */
  2446. /*************************************************************************
  2447. * Name der Methode: findChar()
  2448. *
  2449. * Klasse: StringC
  2450. *
  2451. * Funktion: versucht ein Zeichen im String zu finden
  2452. *
  2453. * Zugriff: public
  2454. *
  2455. * Eingabe-Parameter: 1
  2456. *   char arg_cSearchedChar: Das zu suchende Zeichen
  2457. *
  2458. * Ausgabe-Parameter: der Index des gefundenen Zeichens (-1 für nicht
  2459. *   gefunden)
  2460. *
  2461. * Aufgerufen von: -
  2462. *
  2463. * Verwendung folgender globaler Variablen/Strukturen: -
  2464. *
  2465. * Benutzte Methoden: -
  2466. *
  2467. * Version: 1.0
  2468. *
  2469. * Autor: Christian Taulien of Strange Intelligence
  2470. *
  2471. * Datum: 13. Juni 1997
  2472. *
  2473. * Letzte Änderungen/Neuerungen:
  2474. *   13. Juni 1997:  Methode definiert
  2475. *
  2476. *************************************************************************/
  2477. /*E*/
  2478. {
  2479. TRACEMETHOD
  2480. ASSERT(checkInstance())
  2481.  
  2482.   LONG lFoundIndex=-1;
  2483.   // try for every of our chars
  2484.   for (int i=0; i < getLength(); i++)
  2485.   {
  2486.     // if we found our char
  2487.     if (m_poData->m_sStrPtr[i]==arg_cSearchedChar)
  2488.     {
  2489.       lFoundIndex=i;
  2490.       break;
  2491.     } // if
  2492.   } // for
  2493. return(lFoundIndex);
  2494. }
  2495. /*E*/
  2496. LONG StringC::findCharNot(char arg_cSearchedChar) const
  2497. /*S*/
  2498. /*S*/ /* Methoden-Rahmen */
  2499. /*************************************************************************
  2500. * Name der Methode: findCharNot()
  2501. *
  2502. * Klasse: StringC
  2503. *
  2504. * Funktion: versucht ein anderes Zeichen als das angegebene zu finden
  2505. *
  2506. * Zugriff: public
  2507. *
  2508. * Eingabe-Parameter: 1
  2509. *   char arg_cSearchedChar: Das nicht zu suchende Zeichen
  2510. *
  2511. * Ausgabe-Parameter: der Index des gefundenen Zeichens (-1 für nicht
  2512. *   gefunden)
  2513. *
  2514. * Aufgerufen von: -
  2515. *
  2516. * Verwendung folgender globaler Variablen/Strukturen: -
  2517. *
  2518. * Benutzte Methoden: -
  2519. *
  2520. * Version: 1.1
  2521. *
  2522. * Autor: Christian Taulien of Strange Intelligence
  2523. *
  2524. * Datum:  3. Juli 1997
  2525. *
  2526. * Letzte Änderungen/Neuerungen:
  2527. *   13. Juni 1997:  Methode definiert
  2528. *  3. Juli 1997:  von findChar() übernommen und angepasst
  2529. *
  2530. *************************************************************************/
  2531. /*E*/
  2532. {
  2533. TRACEMETHOD
  2534. ASSERT(checkInstance())
  2535.   LONG lFoundIndex=-1;
  2536.   // try for every of our chars
  2537.   for (int i=0; i < getLength(); i++)
  2538.   {
  2539.     // if we found our char
  2540.     if (m_poData->m_sStrPtr[i]!=arg_cSearchedChar)
  2541.     {
  2542.       lFoundIndex=i;
  2543.       break;
  2544.     } // if
  2545.   } // for
  2546. return(lFoundIndex);
  2547. }
  2548. /*E*/
  2549. LONG StringC::findCharReverse(char arg_cSearchedChar) const
  2550. /*S*/
  2551. /*S*/ /* Methoden-Rahmen */
  2552. /*************************************************************************
  2553. * Name der Methode: findCharReverse()
  2554. *
  2555. * Klasse: StringC
  2556. *
  2557. * Funktion: versucht ein Zeichen im String zu finden (Start von hinten)
  2558. *
  2559. * Zugriff: public
  2560. *
  2561. * Eingabe-Parameter: 1
  2562. *   char arg_cSearchedChar: Das zu suchende Zeichen
  2563. *
  2564. * Ausgabe-Parameter: der Index des gefundenen Zeichens (-1 für nicht
  2565. *   gefunden)
  2566. *
  2567. * Aufgerufen von: -
  2568. *
  2569. * Verwendung folgender globaler Variablen/Strukturen: -
  2570. *
  2571. * Benutzte Methoden: -
  2572. *
  2573. * Version: 1.0
  2574. *
  2575. * Autor: Christian Taulien of Strange Intelligence
  2576. *
  2577. * Datum: 13. Juni 1997
  2578. *
  2579. * Letzte Änderungen/Neuerungen:
  2580. *   13. Juni 1997:  Methode definiert
  2581. *
  2582. *************************************************************************/
  2583. /*E*/
  2584. {
  2585. TRACEMETHOD
  2586. ASSERT(checkInstance())
  2587.   LONG lFoundIndex=-1;
  2588.   // try for every of our chars
  2589.   for (int i = getLength()-1; i>=0 ; i--)
  2590.   {
  2591.     // if we found our char
  2592.     if (m_poData->m_sStrPtr[i]==arg_cSearchedChar)
  2593.     {
  2594.       lFoundIndex=i;
  2595.       break;
  2596.     } // if
  2597.   } // for
  2598. return(lFoundIndex);
  2599. }
  2600. /*E*/
  2601. LONG StringC::findCharNotReverse(char arg_cSearchedChar) const
  2602. /*S*/
  2603. /*S*/ /* Methoden-Rahmen */
  2604. /*************************************************************************
  2605. * Name der Methode: findCharReverseNot()
  2606. *
  2607. * Klasse: StringC
  2608. *
  2609. * Funktion: versucht ein anderes Zeichen als das angegebene zu finden
  2610. *     (Start von hinten)
  2611. *
  2612. * Zugriff: public
  2613. *
  2614. * Eingabe-Parameter: 1
  2615. *   char arg_cSearchedChar: Das nicht zu suchende Zeichen
  2616. *
  2617. * Ausgabe-Parameter: der Index des gefundenen Zeichens (-1 für nicht
  2618. *   gefunden)
  2619. *
  2620. * Aufgerufen von: -
  2621. *
  2622. * Verwendung folgender globaler Variablen/Strukturen: -
  2623. *
  2624. * Benutzte Methoden: -
  2625. *
  2626. * Version: 1.1
  2627. *
  2628. * Autor: Christian Taulien of Strange Intelligence
  2629. *
  2630. * Datum:  3. Juli 1997
  2631. *
  2632. * Letzte Änderungen/Neuerungen:
  2633. *   13. Juni 1997:  Methode definiert
  2634. *  3. Juli 1997:  Von findCharNotReverse() übernommen und angepasst
  2635. *
  2636. *************************************************************************/
  2637. /*E*/
  2638. {
  2639. TRACEMETHOD
  2640. ASSERT(checkInstance())
  2641.   LONG lFoundIndex=-1;
  2642.   // try for every of our chars
  2643.   for (int i = getLength()-1; i>=0 ; i--)
  2644.   {
  2645.     // if we found our char
  2646.     if (m_poData->m_sStrPtr[i] != arg_cSearchedChar)
  2647.     {
  2648.       lFoundIndex=i;
  2649.       break;
  2650.     } // if
  2651.   } // for
  2652. return(lFoundIndex);
  2653. }
  2654. /*E*/
  2655. LONG StringC::findString(char *arg_sSearchedString) const
  2656. /*S*/
  2657. /*S*/ /* Methoden-Rahmen */
  2658. /*************************************************************************
  2659. * Name der Methode: findString()
  2660. *
  2661. * Klasse: StringC
  2662. *
  2663. * Funktion: Sucht nach einem String innerhalb eines Strings
  2664. *
  2665. * Zugriff: public
  2666. *
  2667. * Eingabe-Parameter: 1
  2668. *   char *arg_sSearchedString: Zeiger auf den zu suchenden String
  2669. *
  2670. * Ausgabe-Parameter: LONG: index an dem der string anfängt
  2671. *     (-1 = wenn nicht gefunden)
  2672. *
  2673. * Aufgerufen von: -
  2674. *
  2675. * Verwendung folgender globaler Variablen/Strukturen: -
  2676. *
  2677. * Benutzte Methoden: 2
  2678. *   string.h/strlen()
  2679. *   string.h/strncmp()
  2680. *
  2681. * Version: 1.0
  2682. *
  2683. * Autor: Christian Taulien of Strange Intelligence
  2684. *
  2685. * Datum: 14. Juni 1997
  2686. *
  2687. * Letzte Änderungen/Neuerungen:
  2688. *   14. Juni 1997:  Methode definiert
  2689. *
  2690. *************************************************************************/
  2691. /*E*/
  2692. {
  2693. TRACEMETHOD
  2694. ASSERT(checkInstance())
  2695. ASSERT(arg_sSearchedString)
  2696.   LONG lFoundIndex=-1;
  2697.   // if we have something to find at all
  2698.   if (arg_sSearchedString && getBufferSize())
  2699.   {
  2700.     // calculate the length of the argument-string
  2701.     ULONG ulSourceLen=strlen(arg_sSearchedString);
  2702.     // if the search-string is not empty and smaller than or same-sized as the object-string
  2703.     if (ulSourceLen && (ulSourceLen <= getLength()))
  2704.     {
  2705.       // try from left to right
  2706.       for (int i=0; i <= (getLength()-ulSourceLen); i++)
  2707.       {
  2708.         // compare this possibility
  2709.         if (0==strncmp(arg_sSearchedString, m_poData->m_sStrPtr+i, ulSourceLen))
  2710.         {
  2711.           // Ahh! We found the string
  2712.           lFoundIndex=i;
  2713.           break;
  2714.         } // if
  2715.       } // for
  2716.     } // if
  2717.   } // if
  2718. return(lFoundIndex);
  2719. }
  2720. /*E*/
  2721. LONG StringC::findString(const StringC &arg_roSearchedString) const
  2722. /*S*/
  2723. /*S*/ /* Methoden-Rahmen */
  2724. /*************************************************************************
  2725. * Name der Methode: findString()
  2726. *
  2727. * Klasse: StringC
  2728. *
  2729. * Funktion: Sucht nach einem String innerhalb eines Strings
  2730. *
  2731. * Zugriff: public
  2732. *
  2733. * Eingabe-Parameter: 1
  2734. *   StringC &arg_roSearchedString: Referenz auf das zu suchenden StringC-Obj
  2735. *
  2736. * Ausgabe-Parameter: LONG: Index an dem der String anfängt
  2737. *     -1 = wenn nicht gefunden
  2738. *
  2739. * Aufgerufen von: -
  2740. *
  2741. * Verwendung folgender globaler Variablen/Strukturen: -
  2742. *
  2743. * Benutzte Methoden: 1
  2744. *   string.h/strncmp()
  2745. *
  2746. * Version: 1.0
  2747. *
  2748. * Autor: Christian Taulien of Strange Intelligence
  2749. *
  2750. * Datum: 14. Juni 1997
  2751. *
  2752. * Letzte Änderungen/Neuerungen:
  2753. *   14. Juni 1997:  Methode definiert
  2754. *
  2755. *************************************************************************/
  2756. /*E*/
  2757. {
  2758. TRACEMETHOD
  2759. ASSERT(checkInstance())
  2760. ASSERT(arg_roSearchedString.checkInstance())
  2761.   LONG lFoundIndex=-1;
  2762.   // if we have something to find at all
  2763.   if (arg_roSearchedString.getBufferSize() && getBufferSize())
  2764.   {
  2765.     ULONG ulSourceLen = arg_roSearchedString.getLength();
  2766.     // if the search-string is not empty and smaller than or same-sized as the object-string
  2767.     if (ulSourceLen && (ulSourceLen <= getBufferSize()))
  2768.     {
  2769.       // search from left to right
  2770.       for (int i=0; i <= (getLength()-ulSourceLen); i++)
  2771.       {
  2772.         // try this possibility
  2773.         if (0==strncmp(arg_roSearchedString, m_poData->m_sStrPtr+i, ulSourceLen))
  2774.         {
  2775.           // if we found the string
  2776.           lFoundIndex=i;
  2777.           break;
  2778.         } // if
  2779.       } // for
  2780.     } // if
  2781.   } // if
  2782. return(lFoundIndex);
  2783. }
  2784. /*E*/
  2785. LONG StringC::findStringNoCase(char *arg_sSearchedString) const
  2786. /*S*/
  2787. /*S*/ /* Methoden-Rahmen */
  2788. /*************************************************************************
  2789. * Name der Methode: findStringNoCase()
  2790. *
  2791. * Klasse: StringC
  2792. *
  2793. * Funktion: Sucht nach einem String innerhalb eines Strings ohne Beachtung
  2794. *   der Groß- und Kleinschreibung
  2795. *
  2796. * Zugriff: public
  2797. *
  2798. * Eingabe-Parameter: 1
  2799. *   char *arg_sSearchedString: Zeiger auf den zu suchenden String
  2800. *
  2801. * Ausgabe-Parameter: LONG: index an dem der string anfängt (-1=nicht vorhanden)
  2802. *
  2803. * Aufgerufen von: -
  2804. *
  2805. * Verwendung folgender globaler Variablen/Strukturen: -
  2806. *
  2807. * Benutzte Methoden: 2
  2808. *   string.h/strlen()
  2809. *   utility.library/Strnicmp()
  2810. *
  2811. * Version: 1.0
  2812. *
  2813. * Autor: Christian Taulien of Strange Intelligence
  2814. *
  2815. * Datum: 14. Juni 1997
  2816. *
  2817. * Letzte Änderungen/Neuerungen:
  2818. *   14. Juni 1997:  Methode definiert
  2819. *
  2820. *************************************************************************/
  2821. /*E*/
  2822. {
  2823. TRACEMETHOD
  2824. ASSERT(checkInstance())
  2825. ASSERT(arg_sSearchedString)
  2826.   LONG lFoundIndex=-1;
  2827.   // if we have something to find at all
  2828.   if (arg_sSearchedString && getBufferSize())
  2829.   {
  2830.     ULONG ulSourceLen=strlen(arg_sSearchedString);
  2831.     // if the search-string is not empty and smaller than or same-sized as the object-string
  2832.     if (ulSourceLen && (ulSourceLen <= getLength()))
  2833.     {
  2834.       // search from left to right
  2835.       for (int i=0; i <= (getLength()-ulSourceLen); i++)
  2836.       {
  2837.         // try this possibility
  2838.         if (0==Strnicmp(arg_sSearchedString, m_poData->m_sStrPtr+i, ulSourceLen))
  2839.         {
  2840.           // if we found the string
  2841.           lFoundIndex=i;
  2842.           break;
  2843.         } // if
  2844.       } // for
  2845.     } // if
  2846.   } // if
  2847. return(lFoundIndex);
  2848. }
  2849. /*E*/
  2850. LONG StringC::findStringNoCase(const StringC &arg_roSearchedString) const
  2851. /*S*/
  2852. /*S*/ /* Methoden-Rahmen */
  2853. /*************************************************************************
  2854. * Name der Methode: findStringNoCase()
  2855. *
  2856. * Klasse: StringC
  2857. *
  2858. * Funktion: Sucht nach einem String innerhalb eines Strings ohne beachtung der
  2859. *   Groß- und Kleinschreibung
  2860. *
  2861. * Zugriff: public
  2862. *
  2863. * Eingabe-Parameter: 1
  2864. *   StringC &arg_roSearchedString: Referenz auf das zu suchenden StringC-Obj
  2865. *
  2866. * Ausgabe-Parameter: LONG: index an dem der string anfängt (-1=nicht vorhanden)
  2867. *
  2868. * Aufgerufen von: -
  2869. *
  2870. * Verwendung folgender globaler Variablen/Strukturen: -
  2871. *
  2872. * Benutzte Methoden: 1
  2873. *   utility.library/Strnicmp()
  2874. *
  2875. * Version: 1.0
  2876. *
  2877. * Autor: Christian Taulien of Strange Intelligence
  2878. *
  2879. * Datum: 14. Juni 1997
  2880. *
  2881. * Letzte Änderungen/Neuerungen:
  2882. *   14. Juni 1997:  Methode definiert
  2883. *
  2884. *************************************************************************/
  2885. /*E*/
  2886. {
  2887. TRACEMETHOD
  2888. ASSERT(checkInstance())
  2889. ASSERT(arg_roSearchedString.checkInstance())
  2890.   LONG lFoundIndex=-1;
  2891.   // if we have something to find at all
  2892.   if (arg_roSearchedString.getBufferSize() && getBufferSize())
  2893.   {
  2894.     ULONG ulSourceLen=arg_roSearchedString.getLength();
  2895.     // if the search-string is not empty and smaller than or same-sized as the object-string
  2896.     if (ulSourceLen && (ulSourceLen <= getLength()))
  2897.     {
  2898.       // Search from left to right
  2899.       for (int i=0; i <= (getLength()-ulSourceLen); i++)
  2900.       {
  2901.         // try this possibility
  2902.         if (0==Strnicmp(arg_roSearchedString, m_poData->m_sStrPtr+i, ulSourceLen))
  2903.         {
  2904.           // if we found the string
  2905.           lFoundIndex=i;
  2906.           break;
  2907.         } // if
  2908.       } // for
  2909.     } // if
  2910.   } // if
  2911. return(lFoundIndex);
  2912. }
  2913. /*E*/
  2914. LONG StringC::findOneOf(char *arg_sCharSet) const
  2915. /*S*/
  2916. /*S*/ /* Methoden-Rahmen */
  2917. /*************************************************************************
  2918. * Name der Methode: findOneOf()
  2919. *
  2920. * Klasse: StringC
  2921. *
  2922. * Funktion: Sucht nach meheren Zeichen zugleich.
  2923. *
  2924. * Zugriff: public
  2925. *
  2926. * Eingabe-Parameter: 1
  2927. *   arg_sCharSet:   Zeichenkette, die die gesuchten Zeichen enthält
  2928. *
  2929. * Ausgabe-Parameter: LONG: Index, an dem das erste Zeichen vom Set gefun-
  2930. *   den wurde. -1 wenn nichts gefunden wurde
  2931. *
  2932. * Aufgerufen von: -
  2933. *
  2934. * Verwendung folgender globaler Variablen/Strukturen: -
  2935. *
  2936. * Benutzte Methoden: 1
  2937. *   string.h/strlen()
  2938. *
  2939. * Version: 1.0
  2940. *
  2941. * Autor: Christian Taulien of Strange Intelligence
  2942. *
  2943. * Datum: 14. Juni 1997
  2944. *
  2945. * Letzte Änderungen/Neuerungen:
  2946. *   14. Juni 1997:  Methode definiert
  2947. *
  2948. *************************************************************************/
  2949. /*E*/
  2950. {
  2951. TRACEMETHOD
  2952. ASSERT(checkInstance())
  2953. ASSERT(arg_sCharSet)
  2954.  
  2955.   LONG lFoundIndex=-1;
  2956.   BOOL fFound=FALSE;
  2957.  
  2958.   // if we got something to find at all
  2959.   if (arg_sCharSet && getBufferSize())
  2960.   {
  2961.     // Calculate the length of the set
  2962.     ULONG ulCharSetLen=strlen(arg_sCharSet);
  2963.  
  2964.     // Search from left to right
  2965.     for (int i=0; i<getLength() && !fFound; i++)
  2966.     {
  2967.       // Try this index with every char in the set
  2968.       for (int j=0; j<ulCharSetLen && !fFound; j++)
  2969.       {
  2970.         // Try this combination
  2971.         if (m_poData->m_sStrPtr[i]==arg_sCharSet[j])
  2972.         {
  2973.           // if we found the char
  2974.           lFoundIndex=i;
  2975.           fFound=TRUE;
  2976.           break;
  2977.         } // if
  2978.       } // for
  2979.     } // for
  2980.   } // if
  2981. return(lFoundIndex);
  2982. }
  2983. /*E*/
  2984. void StringC::makeUpper(void)
  2985. /*S*/
  2986. /*S*/ /* Methoden-Rahmen */
  2987. /*************************************************************************
  2988. * Name der Methode: makeUpper()
  2989. *
  2990. * Klasse: StringC
  2991. *
  2992. * Funktion: Wandelt den String in Großbuchstaben
  2993. *
  2994. * Zugriff: public
  2995. *
  2996. * Eingabe-Parameter: -
  2997. *
  2998. * Ausgabe-Parameter: -
  2999. *
  3000. * Aufgerufen von: -
  3001. *
  3002. * Verwendung folgender globaler Variablen/Strukturen: -
  3003. *
  3004. * Benutzte Methoden: 1
  3005. *   utility.library/ToUpper()
  3006. *
  3007. * Version: 1.0
  3008. *
  3009. * Autor: Christian Taulien of Strange Intelligence
  3010. *
  3011. * Datum: 13. Juni 1997
  3012. *
  3013. * Letzte Änderungen/Neuerungen:
  3014. *   13. Juni 1997:  Methode definiert
  3015. *
  3016. *************************************************************************/
  3017. /*E*/
  3018. {
  3019. ASSERT(checkInstance())
  3020.   prepareModify();
  3021.   for (int i=0; i<getLength(); i++)
  3022.   {
  3023.     m_poData->m_sStrPtr[i] = ToUpper(m_poData->m_sStrPtr[i]);
  3024.   } // for
  3025. }
  3026. /*E*/
  3027. void StringC::makeLower(void)
  3028. /*S*/
  3029. /*S*/ /* Methoden-Rahmen */
  3030. /*************************************************************************
  3031. * Name der Methode: makeLower()
  3032. *
  3033. * Klasse: StringC
  3034. *
  3035. * Funktion: Wandelt einen String in Kleinbuchstaben
  3036. *
  3037. * Zugriff: public
  3038. *
  3039. * Eingabe-Parameter: -
  3040. *
  3041. * Ausgabe-Parameter: -
  3042. *
  3043. * Aufgerufen von: -
  3044. *
  3045. * Verwendung folgender globaler Variablen/Strukturen: -
  3046. *
  3047. * Benutzte Methoden: 1
  3048. *   utility.library/ToLower()
  3049. *
  3050. * Version: 1.0
  3051. *
  3052. * Autor: Christian Taulien of Strange Intelligence
  3053. *
  3054. * Datum: 13. Juni 1997
  3055. *
  3056. * Letzte Änderungen/Neuerungen:
  3057. *   13. Juni 1997:  Methode definiert
  3058. *
  3059. *************************************************************************/
  3060. /*E*/
  3061. {
  3062. TRACEMETHOD
  3063. ASSERT(checkInstance())
  3064.   prepareModify();
  3065.   for (int i=0; i<getLength(); i++)
  3066.   {
  3067.     m_poData->m_sStrPtr[i] = ToLower(m_poData->m_sStrPtr[i]);
  3068.   } // for
  3069. }
  3070. /*E*/
  3071. void StringC::makeReverse(void)
  3072. /*S*/
  3073. /*S*/ /* Methoden-Rahmen */
  3074. /*************************************************************************
  3075. * Name der Methode: makeReverse()
  3076. *
  3077. * Klasse: StringC
  3078. *
  3079. * Funktion: Tauscht die Groß- und Kleinschreibung eines Strings
  3080. *
  3081. * Zugriff: public
  3082. *
  3083. * Eingabe-Parameter: -
  3084. *
  3085. * Ausgabe-Parameter: -
  3086. *
  3087. * Aufgerufen von: -
  3088. *
  3089. * Verwendung folgender globaler Variablen/Strukturen: -
  3090. *
  3091. * Benutzte Methoden: 2
  3092. *   utility.library/ToLower()
  3093. *   utility.library/ToUpper()
  3094. *
  3095. * Version: 1.0
  3096. *
  3097. * Autor: Christian Taulien of Strange Intelligence
  3098. *
  3099. * Datum: 13. Juni 1997
  3100. *
  3101. * Letzte Änderungen/Neuerungen:
  3102. *   13. Juni 1997:  Methode definiert
  3103. *
  3104. *************************************************************************/
  3105. /*E*/
  3106. {
  3107. TRACEMETHOD
  3108. ASSERT(checkInstance())
  3109.   prepareModify();
  3110.   for (int i=0; i<getLength(); i++)
  3111.   {
  3112.     // if the lower is the same
  3113.     if (m_poData->m_sStrPtr[i]==ToLower(m_poData->m_sStrPtr[i]))
  3114.     {
  3115.       // convert it to uppercase
  3116.       m_poData->m_sStrPtr[i]=ToUpper(m_poData->m_sStrPtr[i]);
  3117.     }
  3118.     else
  3119.     {
  3120.       // otherwise to lowercase
  3121.       m_poData->m_sStrPtr[i]=ToLower(m_poData->m_sStrPtr[i]);
  3122.     } // if
  3123.   } // for
  3124. }
  3125. /*E*/
  3126. void StringC::trimRight(void)
  3127. /*S*/
  3128. /*S*/ /* Methoden-Rahmen */
  3129. /*************************************************************************
  3130. * Name der Methode: trimRight()
  3131. *
  3132. * Klasse: StringC
  3133. *
  3134. * Funktion: Entfernt alle anhängenden Leerzeichen
  3135. *
  3136. * Zugriff: public
  3137. *
  3138. * Eingabe-Parameter: -
  3139. *
  3140. * Ausgabe-Parameter: -
  3141. *
  3142. * Aufgerufen von: -
  3143. *
  3144. * Verwendung folgender globaler Variablen/Strukturen: -
  3145. *
  3146. * Benutzte Methoden: 3
  3147. *   freeBuffer()
  3148. *   prepareModify()
  3149. *   getBufferSize()
  3150. *
  3151. * Version: 1.1
  3152. *
  3153. * Autor: Christian Taulien of Strange Intelligence
  3154. *
  3155. * Datum: 25. Mai 1998
  3156. *
  3157. * Letzte Änderungen/Neuerungen:
  3158. *   13. Juni 1997:  Methode definiert
  3159. *   25. Mai 1998:   Bug beseitigt, der durch falsche getLength()-Anwendung
  3160. *                     Assertions hervorrief
  3161. *
  3162. *************************************************************************/
  3163. /*E*/
  3164. {
  3165. TRACEMETHOD
  3166. ASSERT(checkInstance())
  3167.  
  3168.   prepareModify();
  3169.   // if we got a buffer at all
  3170.   if (getBufferSize())
  3171.   {
  3172.     // As long as our length is not zero and the last byte is a space
  3173.     while(m_poData->m_ulStrLen && m_poData->m_sStrPtr[m_poData->m_ulStrLen-1]==' ')
  3174.     {
  3175.       // decrement our length counter
  3176.       m_poData->m_ulStrLen--;
  3177.     } // while
  3178.  
  3179.     // if we left no char
  3180.     if (!m_poData->m_ulStrLen)
  3181.     {
  3182.       freeBuffer();
  3183.     }
  3184.     else
  3185.     {
  3186.       // append a zero-byte
  3187.       m_poData->m_sStrPtr[m_poData->m_ulStrLen] = 0;
  3188.     } // if
  3189.   } // if
  3190. }
  3191. /*E*/
  3192. void StringC::trimLeft(void)
  3193. /*S*/
  3194. /*S*/ /* Methoden-Rahmen */
  3195. /*************************************************************************
  3196. * Name der Methode: trimLeft()
  3197. *
  3198. * Klasse: StringC
  3199. *
  3200. * Funktion: Entfernt alle voranstehenden Leerzeichen
  3201. *
  3202. * Zugriff: public
  3203. *
  3204. * Eingabe-Parameter: -
  3205. *
  3206. * Ausgabe-Parameter: -
  3207. *
  3208. * Aufgerufen von: -
  3209. *
  3210. * Verwendung folgender globaler Variablen/Strukturen: -
  3211. *
  3212. * Benutzte Methoden: 4
  3213. *   freeBuffer()
  3214. *   string.h/memcpy()
  3215. *   prepareModify()
  3216. *   getBufferSize()
  3217. *
  3218. * Version: 1.1
  3219. *
  3220. * Autor: Christian Taulien of Strange Intelligence
  3221. *
  3222. * Datum: 25. Mai 1998
  3223. *
  3224. * Letzte Änderungen/Neuerungen:
  3225. *   13. Juni 1997:  Methode definiert
  3226. *   25. Mai 1998:   Bug beseitigt, der durch falsche getLength()-Anwendung
  3227. *                     Assertions hervorrief
  3228. *
  3229. *************************************************************************/
  3230. /*E*/
  3231. {
  3232. TRACEMETHOD
  3233. ASSERT(checkInstance())
  3234.   prepareModify();
  3235.   // if we have a buffer at all
  3236.   if (getBufferSize())
  3237.   {
  3238.     ULONG ulIndex=0;
  3239.     while ((ulIndex < getLength()) && m_poData->m_sStrPtr[ulIndex]==' ') ulIndex++;
  3240.  
  3241.     // if we found at least one space
  3242.     if (ulIndex)
  3243.     {
  3244.       // calculate the new stringlength
  3245.       m_poData->m_ulStrLen-=ulIndex;
  3246.  
  3247.       // if our String length decreased to zero
  3248.       if (!m_poData->m_ulStrLen)
  3249.       {
  3250.         freeBuffer();
  3251.       }
  3252.       else
  3253.       {
  3254.         // otherwise move the string to beginning of the buffer
  3255.         memcpy(m_poData->m_sStrPtr, m_poData->m_sStrPtr+ulIndex, m_poData->m_ulStrLen);
  3256.         m_poData->m_sStrPtr[m_poData->m_ulStrLen]=0;
  3257.       } // if
  3258.     } // if
  3259.   } // if
  3260. }
  3261. /*E*/
  3262. void StringC::trimString(void)
  3263. /*S*/
  3264. /*S*/ /* Methoden-Rahmen */
  3265. /*************************************************************************
  3266. * Name der Methode: trimString()
  3267. *
  3268. * Klasse: StringC
  3269. *
  3270. * Funktion: Entfernt alle voranstehenden und hintanstehenden Leerzeichen
  3271. *
  3272. * Zugriff: public
  3273. *
  3274. * Eingabe-Parameter: -
  3275. *
  3276. * Ausgabe-Parameter: -
  3277. *
  3278. * Aufgerufen von:
  3279. *
  3280. * Verwendung folgender globaler Variablen/Strukturen:
  3281. *
  3282. * Benutzte Methoden: 2
  3283. *   trimLeft();
  3284. *   trimRight();
  3285. *
  3286. * Version: 1.0
  3287. *
  3288. * Autor: Christian Taulien of Strange Intelligence
  3289. *
  3290. * Datum:  2. Juli 1997
  3291. *
  3292. * Letzte Änderungen/Neuerungen:
  3293. *  2. Juli 1997:  Methode definiert
  3294. *
  3295. *************************************************************************/
  3296. /*E*/
  3297. {
  3298. TRACEMETHOD
  3299.   trimLeft();
  3300.   trimRight();
  3301. }
  3302. /*E*/
  3303. void StringC::formatString(char *arg_sFormat, ...)
  3304. /*S*/
  3305. /*S*/ /* Methoden-Rahmen */
  3306. /*************************************************************************
  3307. * Name der Methode: formatString()
  3308. *
  3309. * Klasse: StringC
  3310. *
  3311. * Funktion: Formatieren eines Strings
  3312. *
  3313. * Zugriff: public
  3314. *
  3315. * Eingabe-Parameter: 1+
  3316. *   char *arg_sFormat: Zeiger auf eine Zeichenkette mit Format angaben
  3317. *   ... Die variable Parameterliste entsprechend dem 1. Parameter
  3318. *
  3319. * Ausgabe-Parameter: -
  3320. *
  3321. * Aufgerufen von: -
  3322. *
  3323. * Verwendung folgender globaler Variablen/Strukturen: -
  3324. *
  3325. * Benutzte Methoden: 7
  3326. *   ObjectXC::ObjectXC()
  3327. *   stdio.h/vsprintf()
  3328. *   string.h/strlen()
  3329. *   validateInstance()
  3330. *   getStringTableEntry()
  3331. *   stdarg.h/va_start()
  3332. *   stdarg.h/va_end()
  3333. *
  3334. * Version: 1.0
  3335. *
  3336. * Autor: Christian Taulien of Strange Intelligence
  3337. *
  3338. * Datum: 14. Juni 1997
  3339. *
  3340. * Letzte Änderungen/Neuerungen:
  3341. *   14. Juni 1997:  Methode definiert
  3342. *
  3343. *************************************************************************/
  3344. /*E*/
  3345. {
  3346. TRACEMETHOD
  3347. ASSERT(checkInstance())
  3348. ASSERT(arg_sFormat)
  3349.   prepareModify();
  3350.   if (!getBufferSize())
  3351.   {
  3352.     throw STRINGC_XC;
  3353.   } // if
  3354.  
  3355.   if (!arg_sFormat)
  3356.   {
  3357.     throw STRINGC_XC;
  3358.   } // if
  3359.  
  3360. ASSERT(strlen(arg_sFormat)<=getBufferSize())
  3361.  
  3362.   va_list arg;
  3363.   va_start(arg,arg_sFormat);
  3364.   vsprintf(m_poData->m_sStrPtr, arg_sFormat, arg);
  3365.   va_end(arg);
  3366.   validateInstance();
  3367. }
  3368. /*E*/
  3369. void StringC::fillString(char arg_cFillByte)
  3370. /*S*/
  3371. /*S*/ /* Methoden-Rahmen */
  3372. /*************************************************************************
  3373. * Name der Methode: fillString()
  3374. *
  3375. * Klasse: StringC
  3376. *
  3377. * Funktion: Füllt den String mit einem bestimmten Zeichen
  3378. *
  3379. * Zugriff: public
  3380. *
  3381. * Eingabe-Parameter: 1
  3382. *   char arg_cFillByte: Das Zeichen mit dem der String gefüllt werden soll
  3383. *
  3384. * Ausgabe-Parameter: -
  3385. *
  3386. * Aufgerufen von: -
  3387. *
  3388. * Verwendung folgender globaler Variablen/Strukturen: -
  3389. *
  3390. * Benutzte Methoden: -
  3391. *
  3392. * Version: 1.0
  3393. *
  3394. * Autor: Christian Taulien of Strange Intelligence
  3395. *
  3396. * Datum: 14. Juni 1997
  3397. *
  3398. * Letzte Änderungen/Neuerungen:
  3399. *   14. Juni 1997:  Methode definiert
  3400. *
  3401. *************************************************************************/
  3402. /*E*/
  3403. {
  3404. TRACEMETHOD
  3405. ASSERT(checkInstance())
  3406.   prepareModify();
  3407.   if (getBufferSize())
  3408.   {
  3409.     for (int i=0; i<getLength(); i++)
  3410.     {
  3411.       m_poData->m_sStrPtr[i]=arg_cFillByte;
  3412.     } // for
  3413.   } // if
  3414.  
  3415.   if (!arg_cFillByte)
  3416.   {
  3417.     m_poData->m_ulStrLen=0;
  3418.   } // if
  3419. }
  3420. /*E*/
  3421.  
  3422. // operator-overloading
  3423. char StringC::operator[](int arg_iIndex)
  3424. /*S*/
  3425. /*S*/ /* Methoden-Rahmen */
  3426. /*************************************************************************
  3427. * Name der Methode: operator[]
  3428. *
  3429. * Klasse: StringC
  3430. *
  3431. * Funktion: Ermittelt das n.te Zeichen des Buffers
  3432. *
  3433. * Zugriff: public
  3434. *
  3435. * Eingabe-Parameter: 1
  3436. *   int arg_iIndex: Das wievielte Zeichen angesprochen werden soll
  3437. *
  3438. * Ausgabe-Parameter: Das Zeichen, das am angegebenen Index steht
  3439. *
  3440. * Aufgerufen von: -
  3441. *
  3442. * Verwendung folgender globaler Variablen/Strukturen: -
  3443. *
  3444. * Benutzte Methoden: 1
  3445. *   resizeBuffer()
  3446. *
  3447. * Version: 1.0
  3448. *
  3449. * Autor: Christian Taulien of Strange Intelligence
  3450. *
  3451. * Datum:  4. Juni 1997
  3452. *
  3453. * Letzte Änderungen/Neuerungen:
  3454. *  4. Juni 1997:  Methode definiert
  3455. *
  3456. *************************************************************************/
  3457. /*E*/
  3458. {
  3459. TRACEMETHOD
  3460. ASSERT(checkInstance())
  3461.   // if the access is out of allocated range
  3462.   if (arg_iIndex >= getBufferSize())
  3463.   {
  3464.     // reallocate memory
  3465.     resizeBuffer(arg_iIndex);
  3466.  
  3467.   } // if (arg_iIndex >= m_ulBufLen)
  3468. return(m_poData->m_sStrPtr[arg_iIndex]);
  3469. }
  3470. /*E*/
  3471. StringC::operator char *() const
  3472. /*S*/
  3473. /*S*/ /* Methoden-Rahmen */
  3474. /*************************************************************************
  3475. * Name der Methode: operator char *()
  3476. *
  3477. * Klasse: StringC
  3478. *
  3479. * Funktion: Cast-Operator für StringC -> char *
  3480. *
  3481. * Zugriff: public
  3482. *
  3483. * Eingabe-Parameter: -
  3484. *
  3485. * Ausgabe-Parameter: automatisch: char *: Zeiger auf die Zeichenkette
  3486. *
  3487. * Aufgerufen von: -
  3488. *
  3489. * Verwendung folgender globaler Variablen/Strukturen: -
  3490. *
  3491. * Benutzte Methoden: -
  3492. *
  3493. * Version: 1.0
  3494. *
  3495. * Autor: Christian Taulien of Strange Intelligence
  3496. *
  3497. * Datum: 15. Oktober 1997
  3498. *
  3499. * Letzte Änderungen/Neuerungen:
  3500. * 15. Oktober 1997: Methode definiert
  3501. *
  3502. *************************************************************************/
  3503. /*E*/
  3504. {
  3505. TRACEMETHOD
  3506. return(m_poData->m_sStrPtr);
  3507. }
  3508. /*E*/
  3509. StringC &StringC::operator= (const char *arg_sString)
  3510. /*S*/
  3511. /*S*/ /* Methoden-Rahmen */
  3512. /*************************************************************************
  3513. * Name der Methode: operator =()
  3514. *
  3515. * Klasse: StringC
  3516. *
  3517. * Funktion: Zuweisungsoperator
  3518. *
  3519. * Zugriff: public
  3520. *
  3521. * Eingabe-Parameter: 1
  3522. *   arg_sString: Der neue String
  3523. *
  3524. * Ausgabe-Parameter: StringC &: Eine Referenz auf das StringC-Objekt
  3525. *
  3526. * Aufgerufen von: -
  3527. *
  3528. * Verwendung folgender globaler Variablen/Strukturen: -
  3529. *
  3530. * Benutzte Methoden: 1
  3531. *   setString()
  3532. *
  3533. * Version: 1.0
  3534. *
  3535. * Autor: Christian Taulien of Strange Intelligence
  3536. *
  3537. * Datum: 10. Oktober 1997
  3538. *
  3539. * Letzte Änderungen/Neuerungen:
  3540. * 10. Oktober 1997: Methode definiert
  3541. *
  3542. *************************************************************************/
  3543. /*E*/
  3544. {
  3545. TRACEMETHOD
  3546. ASSERT(checkInstance())
  3547.   setString(arg_sString);
  3548. return(*this);
  3549. }
  3550. /*E*/
  3551. StringC &StringC::operator= (const StringC &arg_roSrcObj)
  3552. /*S*/
  3553. /*S*/ /* Methoden-Rahmen */
  3554. /*************************************************************************
  3555. * Name der Methode: operator=()
  3556. *
  3557. * Klasse: StringC
  3558. *
  3559. * Funktion: Zuweisunsoperator
  3560. *
  3561. * Zugriff: public
  3562. *
  3563. * Eingabe-Parameter: 1
  3564. *   arg_roSrcObj:  Eine Referenz auf ein StringC-Objekt
  3565. *
  3566. * Ausgabe-Parameter: Eine Referenz auf das behandelte StringC-Objekt
  3567. *
  3568. * Aufgerufen von:
  3569. *
  3570. * Verwendung folgender globaler Variablen/Strukturen: keine
  3571. *
  3572. * Benutzte Methoden: 4
  3573. *   string.h/strncpy()
  3574. *   allocBuffer()
  3575. *   initInstance()
  3576. *   inherited::operator=()
  3577. *
  3578. * Version: 2.2
  3579. *
  3580. * Autor: Christian Taulien of Strange Intelligence
  3581. *
  3582. * Datum: 23. August 1997
  3583. *
  3584. * Letzte Änderungen/Neuerungen:
  3585. *   29. Dezember 1996:  Methode definiert
  3586. *  4. Juni 1997:    Übernommen und komplett überarbeitet vom
  3587. *             Berlin-Projekt
  3588. *   23. August 1997:  Die Basisklasse wird jetzt durch "inherited"
  3589. *             angesprochen
  3590. *   10. Oktober 1997: Leicht optimiert.
  3591. *
  3592. *************************************************************************/
  3593. /*E*/
  3594. {
  3595. TRACEMETHOD
  3596. ASSERT(checkInstance())
  3597. ASSERT(arg_roSrcObj.checkInstance())
  3598.  
  3599.   if (this != &arg_roSrcObj)
  3600.   {
  3601.     freeBuffer();
  3602.     m_poData = arg_roSrcObj.m_poData;
  3603.     incReference();
  3604.   } // if
  3605. return(*this);
  3606. }
  3607. /*E*/
  3608. StringC &StringC::operator += (const StringC &arg_roSummand)
  3609. /*S*/
  3610. /*S*/ /* Methoden-Rahmen */
  3611. /*************************************************************************
  3612. * Name der Methode: operator +=()
  3613. *
  3614. * Klasse: StringC
  3615. *
  3616. * Funktion: Additions/Zuweisungs-Operator
  3617. *
  3618. * Zugriff: public
  3619. *
  3620. * Eingabe-Parameter: 1
  3621. *   const StringC &arg_roSummand:   Eine Referenz auf ein StringC-Objekt
  3622. *
  3623. * Ausgabe-Parameter: Eine Referenz auf das behandelte neue StringC-Objekt
  3624. *
  3625. * Aufgerufen von: -
  3626. *
  3627. * Verwendung folgender globaler Variablen/Strukturen: -
  3628. *
  3629. * Benutzte Methoden: 2
  3630. *   resizeBuffer()
  3631. *   string.h/strcat()
  3632. *
  3633. * Version: 2.1
  3634. *
  3635. * Autor: Christian Taulien of Strange Intelligence
  3636. *
  3637. * Datum: 25. Juni 1997
  3638. *
  3639. * Letzte Änderungen/Neuerungen:
  3640. *   11. Januar 1997:  Methode definiert
  3641. *   11. Juni 1997:    Übernommen aus dem Berlin-Projekt und angepasst
  3642. *   25. Juni 1997:    GetLength() wird nicht mehr verwendet. Die Länge
  3643. *             der Teilstrings wird direkt ausgelesen.
  3644. *
  3645. *************************************************************************/
  3646. /*E*/
  3647. {
  3648. TRACEMETHOD
  3649. ASSERT(checkInstance())
  3650. ASSERT(arg_roSummand.checkInstance())
  3651.  
  3652.   // Compute the required length to hold both strings
  3653.   ULONG ulNewLen = getLength() + arg_roSummand.getLength();
  3654.  
  3655.   // if this length is bigger than the existing length
  3656.   if (ulNewLen > getBufferSize())
  3657.   {
  3658.     // allocate the buffer in a appropriate size
  3659.     resizeBuffer(ulNewLen);
  3660.   } // if (ulNewLen > m_ulBufLen)
  3661.   prepareModify();
  3662.  
  3663.   // Concatenate the both strings
  3664.   strcat(m_poData->m_sStrPtr, arg_roSummand.m_poData->m_sStrPtr);
  3665. return(*this);
  3666. }
  3667. /*E*/
  3668. StringC &StringC::operator += (const char *arg_sSummand)
  3669. /*S*/
  3670. /*S*/ /* Methoden-Rahmen */
  3671. /*************************************************************************
  3672. * Name der Methode: operator +=()
  3673. *
  3674. * Klasse: StringC
  3675. *
  3676. * Funktion: Additions/Zuweisungs-Operator
  3677. *
  3678. * Zugriff: public
  3679. *
  3680. * Eingabe-Parameter: 1
  3681. *   const char *arg_sSummand:   Ein Zeiger auf den anzuhängenden String
  3682. *
  3683. * Ausgabe-Parameter: Eine Referenz auf das behandelte neue StringC-Objekt
  3684. *
  3685. * Aufgerufen von: -
  3686. *
  3687. * Verwendung folgender globaler Variablen/Strukturen: -
  3688. *
  3689. * Benutzte Methoden: 3
  3690. *   resizeBuffer()
  3691. *   string.h/strcat()
  3692. *   string.h/strlen()
  3693. *
  3694. * Version: 2.1
  3695. *
  3696. * Autor: Christian Taulien of Strange Intelligence
  3697. *
  3698. * Datum: 25. Juni 1997
  3699. *
  3700. * Letzte Änderungen/Neuerungen:
  3701. *   11. Januar 1997:  Methode definiert
  3702. *   11. Juni 1997:    Übernommen aus dem Berlin-Projekt / angepasst
  3703. *   25. Juni 1997:    GetLength() wird nicht mehr verwendet. Die Länge
  3704. *             der Teilstrings wird direkt ausgelesen.
  3705. *
  3706. *************************************************************************/
  3707. /*E*/
  3708. {
  3709. TRACEMETHOD
  3710. ASSERT(checkInstance())
  3711.  
  3712.   // Compute the required length to hold both strings
  3713.   ULONG ulNewLen = getLength() + strlen(arg_sSummand);
  3714.  
  3715.   // if this length is bigger than the existing length
  3716.   if (ulNewLen > getBufferSize())
  3717.   {
  3718.     // allocate the buffer in a appropriate size
  3719.     resizeBuffer(ulNewLen);
  3720.   } // if (ulNewLen > m_ulBufLen)
  3721.   prepareModify();
  3722.  
  3723.   // conatenate the both strings
  3724.   strcat(m_poData->m_sStrPtr, arg_sSummand);
  3725. return(*this);
  3726. }
  3727. /*E*/
  3728. StringC &StringC::operator += (const char arg_cSummand)
  3729. /*S*/
  3730. /*S*/ /* Methoden-Rahmen */
  3731. /*************************************************************************
  3732. * Name der Methode: operator +=()
  3733. *
  3734. * Klasse: StringC
  3735. *
  3736. * Funktion: Additions/Zuweisungs-Operator
  3737. *
  3738. * Zugriff: public
  3739. *
  3740. * Eingabe-Parameter: 1
  3741. *   const char arg_cSummand:   Ein hinzuzufügendes Zeichen
  3742. *
  3743. * Ausgabe-Parameter: Eine Referenz auf das behandelte neue StringC-Objekt
  3744. *
  3745. * Aufgerufen von: -
  3746. *
  3747. * Verwendung folgender globaler Variablen/Strukturen: -
  3748. *
  3749. * Benutzte Methoden: 2
  3750. *   resizeBuffer()
  3751. *   string.h/strlen()
  3752. *
  3753. * Version: 2.2
  3754. *
  3755. * Autor: Christian Taulien of Strange Intelligence
  3756. *
  3757. * Datum: 25. Juni 1997
  3758. *
  3759. * Letzte Änderungen/Neuerungen:
  3760. *   11. Januar 1997:  Methode definiert
  3761. *   11. Juni 1997:    Übernommen aus dem Berlin-Projekt / angepasst
  3762. *   25. Juni 1997:    GetLength() wird nicht mehr verwendet. Die Länge
  3763. *             der Teilstrings wird direkt ausgelesen.
  3764. *             Es wird nun auch die neue Länge explizit berech-
  3765. *             net
  3766. *
  3767. *************************************************************************/
  3768. /*E*/
  3769. {
  3770. TRACEMETHOD
  3771. ASSERT(checkInstance())
  3772.   // Compute the required length to hold both strings
  3773.   ULONG ulNewLen = getLength() + sizeof(char);
  3774.  
  3775.   // if this length is bigger than the existing length
  3776.   if (ulNewLen > getBufferSize())
  3777.   {
  3778.     // allocate the buffer in a appropriate size
  3779.     resizeBuffer(ulNewLen);
  3780.   }
  3781.   prepareModify();
  3782.  
  3783.   // append the char
  3784.   m_poData->m_sStrPtr[ulNewLen-sizeof(char)]=arg_cSummand;
  3785.   m_poData->m_sStrPtr[ulNewLen]=0;
  3786.  
  3787.   // recalculate the new strlen explicitly
  3788.   m_poData->m_ulStrLen = strlen(m_poData->m_sStrPtr);
  3789. return(*this);
  3790. }
  3791. /*E*/
  3792. StringC operator+(const StringC &arg_roFirst, const StringC &arg_roSecond)
  3793. /*S*/
  3794. /*S*/ /* Methoden-Rahmen */
  3795. /*************************************************************************
  3796. * Name der Methode: operator +
  3797. *
  3798. * Klasse: StringC
  3799. *
  3800. * Funktion: Aneinanderhängen zweier StringC-Object zu einem StringC-Object
  3801. *
  3802. * Zugriff: public
  3803. *
  3804. * Eingabe-Parameter: 2
  3805. *   zwei Referenzen von Objekten der Klasse StringC
  3806. *
  3807. * Ausgabe-Parameter: Ein neues StringC-Objekt
  3808. *
  3809. * Aufgerufen von:
  3810. *
  3811. * Verwendung folgender globaler Variablen/Strukturen:
  3812. *
  3813. * Benutzte Methoden: 8
  3814. *   ObjectXC::ObjectXC()
  3815. *   StringC() Direkt-Set-Konstruktor [private]
  3816. *   StringC() Einfacher Konstruktor
  3817. *   isEmpty()
  3818. *   string.h/strcpy()
  3819. *   string.h/strcat()
  3820. *   string.h/strlen()
  3821. *   getStringTableEntry()
  3822. *
  3823. * Version: 1.5
  3824. *
  3825. * Autor: Christian Taulien of Strange Intelligence
  3826. *
  3827. * Datum:  25. Juni 1997
  3828. *
  3829. * Letzte Änderungen/Neuerungen:
  3830. *  9. November 1996:  Methode implementiert
  3831. *   11. November 1996:  Sicherheit erhöht, durch Verwendung von getLen() und Existenz-Tests
  3832. *             wenn die Strings in den neuen kopiert werden.
  3833. *   12. Januar 1997:  Die Methode gibt nun einen Zeiger auf das neue Objekt, anstatt
  3834. *             eine Referenz darauf zurück.
  3835. *  6. Februar 1997:   Die Methode gibt keinen Zeiger mehr auf das neue Objekt zurück sondern
  3836. *             returniert ein komplett neues Objekt, weil vorher das mit new erzeugte
  3837. *             Return-Objekt nicht wieder gelöscht wurde. Für die Rückgabe wird der
  3838. *             Direktset-Konstruktor verwendet, so daß nur 1 temporäres Objekt auf dem
  3839. *             Stack erzeugt werden muß. Es scheint unmöglich für einen + operator ein
  3840. *             Temporäres Objekt zu vermeiden.
  3841. *             Desweiteren wurde die Länge jetzt richtig bemessen (vorher 1 Byte zuviel)
  3842. *   11-12. Juni 1997:   Methode aus dem Berlin-Projekt übernommen und angepasst
  3843. *             1 Bug wurde beseitigt (Semikolon in if-Zeile)
  3844. *   25. Juni 1997:    GetLength() wird nicht mehr verwendet. Die Länge
  3845. *             der Teilstrings wird direkt ausgelesen.
  3846. *
  3847. *************************************************************************/
  3848. /*E*/
  3849. {
  3850. ASSERT(arg_roSecond.checkInstance())
  3851.   // Compute the buffersize required to hold both strings
  3852.   ULONG ulNewLen=arg_roFirst.getLength() + arg_roSecond.getLength();
  3853.  
  3854.   // a size of zero results in a zero-object
  3855.   if (!ulNewLen)
  3856.   {
  3857.     return(StringC());
  3858.   } // if
  3859.  
  3860.   // make the string divideable by 8
  3861.   ULONG ulNewBufLen=(ulNewLen+8) & (~0x7);
  3862.  
  3863.   // allocate the new buffer
  3864.   char *sNewPtr;
  3865.   if (!(sNewPtr = new char [ulNewBufLen]))
  3866.   {
  3867.     // if something went wrong (e.g. no memory)
  3868.     throw STRINGC_XC;
  3869.   } //if
  3870.  
  3871.   // fill the just allocated buffer
  3872.   if (!arg_roFirst.isEmpty())
  3873.   {
  3874.     strcpy(sNewPtr, arg_roFirst.m_poData->m_sStrPtr);
  3875.   } //if
  3876.  
  3877.   if (!arg_roSecond.isEmpty())
  3878.   {
  3879.     strcat(sNewPtr, arg_roSecond.m_poData->m_sStrPtr);
  3880.   } //if
  3881.  
  3882. // use a special direct-set-constructor to reduce the temporary objects
  3883. return(StringC(ulNewLen,ulNewBufLen-1, sNewPtr));
  3884. }
  3885. /*E*/
  3886. StringC operator+(const StringC &arg_roFirst, char arg_cSecond)
  3887. /*S*/
  3888. /*S*/ /* Methoden-Rahmen */
  3889. /*************************************************************************
  3890. * Name der Methode: operator +
  3891. *
  3892. * Klasse: StringC
  3893. *
  3894. * Funktion: Aneinanderhängen eines StringC-Objects mit einem char
  3895. *
  3896. * Zugriff: public
  3897. *
  3898. * Eingabe-Parameter: 2
  3899. *   Eine Referenz eines Objekten der Klasse StringC
  3900. *   ein char
  3901. *
  3902. * Ausgabe-Parameter: Ein neues StringC-Objekt
  3903. *
  3904. * Aufgerufen von:
  3905. *
  3906. * Verwendung folgender globaler Variablen/Strukturen:
  3907. *
  3908. * Benutzte Methoden: 6
  3909. *   ObjectXC()
  3910. *   StringC() Direkt-Set-Konstruktor [private]
  3911. *   StringC() Einfacher Konstruktor
  3912. *   isEmpty()
  3913. *   string.h/strcpy()
  3914. *   getStringTableEntry()
  3915. *
  3916. * Version: 1.5
  3917. *
  3918. * Autor: Christian Taulien of Strange Intelligence
  3919. *
  3920. * Datum:  25. Juni 1997
  3921. *
  3922. * Letzte Änderungen/Neuerungen:
  3923. *  9. November 1996:  Methode implementiert
  3924. *   11. November 1996:  Sicherheit erhöht, durch Verwendung von getLen() und Existenz-Tests
  3925. *             wenn die Strings in den neuen kopiert werden.
  3926. *   12. Januar 1997:  Die Methode gibt nun einen Zeiger auf das neue Objekt, anstatt
  3927. *             eine Referenz darauf zurück.
  3928. *  6. Februar 1997:   Die Methode gibt keinen Zeiger mehr auf das neue Objekt zurück sondern
  3929. *             returniert ein komplett neues Objekt, weil vorher das mit new erzeugte
  3930. *             Return-Objekt nicht wieder gelöscht wurde. Für die Rückgabe wird der
  3931. *             Direktset-Konstruktor verwendet, so daß nur 1 temporäres Objekt auf dem
  3932. *             Stack erzeugt werden muß. Es scheint unmöglich für einen + operator ein
  3933. *             Temporäres Objekt zu vermeiden.
  3934. *             Desweiteren wurde die Länge jetzt richtig bemessen (vorher 1 Byte zuviel)
  3935. *   11-12. Juni 1997:   Methode aus dem Berlin-Projekt übernommen und angepasst
  3936. *             1 Bug wurde beseitigt (Semikolon in if-Zeile)
  3937. *   25. Juni 1997:    GetLength() wird nicht mehr verwendet. Die Länge
  3938. *             der Teilstrings wird direkt ausgelesen.
  3939. *
  3940. *************************************************************************/
  3941. /*E*/
  3942. {
  3943. ASSERT(arg_roFirst.checkInstance())
  3944.   // Compute the buffersize required to hold both strings
  3945.   ULONG ulNewLen=arg_roFirst.getLength()+sizeof(char);
  3946.  
  3947.   // a size of zero results in a zero-object
  3948.   if (!ulNewLen)
  3949.   {
  3950.     return(StringC());
  3951.   } // if (!ulNewLen)
  3952.  
  3953.   // make the string divideable by 8
  3954.   ULONG ulNewBufLen=(ulNewLen+8) & (~0x7);
  3955.  
  3956.   // allocate the new buffer
  3957.   char *sNewPtr;
  3958.   if (!(sNewPtr = new char [ulNewBufLen]))
  3959.   {
  3960.     // if something went wrong (no mem)
  3961.     throw STRINGC_XC;
  3962.   } // if (m_sStrPtr = new char [(ULONG) arg_ulSize])
  3963.  
  3964.   // fill the just allocated buffer
  3965.   if (!arg_roFirst.isEmpty())
  3966.   {
  3967.     strcpy(sNewPtr, arg_roFirst.m_poData->m_sStrPtr);
  3968.   } //if (!arg_roFirst.isEmpty())
  3969.  
  3970.   sNewPtr[ulNewLen-sizeof(char)]=arg_cSecond;
  3971.   sNewPtr[ulNewLen]=0;
  3972.  
  3973. return(StringC(ulNewLen,ulNewBufLen-sizeof(char), sNewPtr));
  3974. }
  3975. /*E*/
  3976. StringC operator+(char arg_cFirst, const StringC &arg_roSecond)
  3977. /*S*/
  3978. /*S*/ /* Methoden-Rahmen */
  3979. /*************************************************************************
  3980. * Name der Methode: operator +
  3981. *
  3982. * Klasse: StringC
  3983. *
  3984. * Funktion: Aneinanderhängen eines chars mit einem StringC-Object
  3985. *
  3986. * Zugriff: public
  3987. *
  3988. * Eingabe-Parameter: 2
  3989. *   ein char
  3990. *   Eine Referenz eines Objekten der Klasse StringC
  3991. *
  3992. * Ausgabe-Parameter: Ein neues StringC-Objekt
  3993. *
  3994. * Aufgerufen von:
  3995. *
  3996. * Verwendung folgender globaler Variablen/Strukturen:
  3997. *
  3998. * Benutzte Methoden: 6
  3999. *   ObjectXC()
  4000. *   StringC() Direkt-Set-Konstruktor [private]
  4001. *   StringC() Einfacher Konstruktor
  4002. *   isEmpty()
  4003. *   string.h/strcat()
  4004. *   getStringTableEntry()
  4005. *
  4006. * Version: 1.5
  4007. *
  4008. * Autor: Christian Taulien of Strange Intelligence
  4009. *
  4010. * Datum:  25. Juni 1997
  4011. *
  4012. * Letzte Änderungen/Neuerungen:
  4013. *  9. November 1996:  Methode implementiert
  4014. *   11. November 1996:  Sicherheit erhöht, durch Verwendung von getLen() und Existenz-Tests
  4015. *             wenn die Strings in den neuen kopiert werden.
  4016. *   12. Januar 1997:  Die Methode gibt nun einen Zeiger auf das neue Objekt, anstatt
  4017. *             eine Referenz darauf zurück.
  4018. *  6. Februar 1997:   Die Methode gibt keinen Zeiger mehr auf das neue Objekt zurück sondern
  4019. *             returniert ein komplett neues Objekt, weil vorher das mit new erzeugte
  4020. *             Return-Objekt nicht wieder gelöscht wurde. Für die Rückgabe wird der
  4021. *             Direktset-Konstruktor verwendet, so daß nur 1 temporäres Objekt auf dem
  4022. *             Stack erzeugt werden muß. Es scheint unmöglich für einen + operator ein
  4023. *             Temporäres Objekt zu vermeiden.
  4024. *             Desweiteren wurde die Länge jetzt richtig bemessen (vorher 1 Byte zuviel)
  4025. *   11-12. Juni 1997:   Methode aus dem Berlin-Projekt übernommen und angepasst
  4026. *             1 Bug wurde beseitigt (Semikolon in if-Zeile)
  4027. *   25. Juni 1997:    GetLength() wird nicht mehr verwendet. Die Länge
  4028. *             der Teilstrings wird direkt ausgelesen.
  4029. *             Es wurde außerdem der Fall abgefangen, wenn der
  4030. *             char-Parameter==NULL ist
  4031. *
  4032. *************************************************************************/
  4033. /*E*/
  4034. {
  4035. ASSERT(arg_roSecond.checkInstance())
  4036.   // Compute the buffersize required to hold both strings
  4037.   ULONG ulNewLen=arg_roSecond.getLength()+sizeof(char);
  4038.  
  4039.   // a size of zero results in a zero-object
  4040.   if (!ulNewLen)
  4041.   {
  4042.     return(StringC());
  4043.   } // if (!ulNewLen)
  4044.  
  4045.   // if the char is zero, just create a copy of the StringC-object
  4046.   if (!arg_cFirst)
  4047.   {
  4048.     return(StringC(arg_roSecond));
  4049.   }
  4050.  
  4051.   // make the string divideable by 8
  4052.   ULONG ulNewBufLen=(ulNewLen+8) & (~0x7);
  4053.  
  4054.   // allocate the new buffer
  4055.   char *sNewPtr;
  4056.   if (!(sNewPtr = new char [ulNewBufLen]))
  4057.   {
  4058.     // if something went wrong (no mem)
  4059.     throw STRINGC_XC;
  4060.   } // if (m_sStrPtr = new char [(ULONG) arg_ulSize])
  4061.  
  4062.   sNewPtr[0]=arg_cFirst;
  4063.   sNewPtr[sizeof(char)]=0;
  4064.  
  4065.   // fill the just allocated buffer
  4066.   if (!arg_roSecond.isEmpty())
  4067.   {
  4068.     strcat(sNewPtr, arg_roSecond.m_poData->m_sStrPtr);
  4069.   } //if (!arg_roFirst.isEmpty())
  4070.  
  4071. return(StringC(ulNewLen,ulNewBufLen-sizeof(char), sNewPtr));
  4072. }
  4073. /*E*/
  4074. StringC operator+(const StringC &arg_roFirst, const char *arg_sSecond)
  4075. /*S*/
  4076. /*S*/ /* Methoden-Rahmen */
  4077. /*************************************************************************
  4078. * Name der Methode: operator +
  4079. *
  4080. * Klasse: StringC
  4081. *
  4082. * Funktion: Aneinanderhängen eines StringC-Object mit einer Zeichenkette
  4083. *
  4084. * Zugriff: public
  4085. *
  4086. * Eingabe-Parameter: 2
  4087. *   Eine Referenz eines Objekten der Klasse StringC
  4088. *   eine Zeichenkette
  4089. *
  4090. * Ausgabe-Parameter: Ein neues StringC-Objekt
  4091. *
  4092. * Aufgerufen von:
  4093. *
  4094. * Verwendung folgender globaler Variablen/Strukturen:
  4095. *
  4096. * Benutzte Methoden: 7
  4097. *   ObjectXC()
  4098. *   StringC() Direkt-Set-Konstruktor [private]
  4099. *   StringC() Einfacher Konstruktor
  4100. *   isEmpty()
  4101. *   string.h/strcpy()
  4102. *   string.h/strcat()
  4103. *   getStringTableEntry()
  4104. *
  4105. * Version: 1.5
  4106. *
  4107. * Autor: Christian Taulien of Strange Intelligence
  4108. *
  4109. * Datum:  25. Juni 1997
  4110. *
  4111. * Letzte Änderungen/Neuerungen:
  4112. *  9. November 1996:  Methode implementiert
  4113. *   11. November 1996:  Sicherheit erhöht, durch Verwendung von getLen() und Existenz-Tests
  4114. *             wenn die Strings in den neuen kopiert werden.
  4115. *   12. Januar 1997:  Die Methode gibt nun einen Zeiger auf das neue Objekt, anstatt
  4116. *             eine Referenz darauf zurück.
  4117. *  6. Februar 1997:   Die Methode gibt keinen Zeiger mehr auf das neue Objekt zurück sondern
  4118. *             returniert ein komplett neues Objekt, weil vorher das mit new erzeugte
  4119. *             Return-Objekt nicht wieder gelöscht wurde. Für die Rückgabe wird der
  4120. *             Direktset-Konstruktor verwendet, so daß nur 1 temporäres Objekt auf dem
  4121. *             Stack erzeugt werden muß. Es scheint unmöglich für einen + operator ein
  4122. *             Temporäres Objekt zu vermeiden.
  4123. *             Desweiteren wurde die Länge jetzt richtig bemessen (vorher 1 Byte zuviel)
  4124. *   11-12. Juni 1997:   Methode aus dem Berlin-Projekt übernommen und angepasst
  4125. *             1 Bug wurde beseitigt (Semikolon in if-Zeile)
  4126. *   25. Juni 1997:    GetLength() wird nicht mehr verwendet. Die Länge
  4127. *             der Teilstrings wird direkt ausgelesen.
  4128. *             Die Methode wurde optimiert und weiter abgesichert
  4129. *
  4130. *************************************************************************/
  4131. /*E*/
  4132. {
  4133. ASSERT(arg_roFirst.checkInstance())
  4134. ASSERT(arg_sSecond)
  4135.  
  4136.   ULONG ulNewLen=0;
  4137.  
  4138.   // only count the length of the char-pointer if one is there
  4139.   if(arg_sSecond)
  4140.   {
  4141.     ulNewLen = strlen(arg_sSecond);
  4142.   } // if(arg_sSecond)
  4143.  
  4144.   // if the char-pointer is zero or has no length
  4145.   if (!ulNewLen)
  4146.   {
  4147.     // just return a copy of the StringC-object
  4148.     return(StringC(arg_roFirst));
  4149.   } // if (!ulNewLen)
  4150.  
  4151.   // Compute the buffersize required to hold both strings
  4152.   ulNewLen += arg_roFirst.getLength();
  4153.  
  4154.   // make the string divideable by 8
  4155.   ULONG ulNewBufLen=(ulNewLen+8) & (~0x7);
  4156.  
  4157.   // allocate the new buffer
  4158.   char *sNewPtr = new char [ulNewBufLen];
  4159.   if (!sNewPtr)
  4160.   {
  4161.     // if something went wrong (e.g. no memory)
  4162.     throw STRINGC_XC;
  4163.   } // if (m_sStrPtr = new char [(ULONG) arg_ulSize])
  4164.  
  4165.   // fill the just allocated buffer
  4166.   if (!arg_roFirst.isEmpty())
  4167.   {
  4168.     strcpy(sNewPtr, arg_roFirst.m_poData->m_sStrPtr);
  4169.   } // if (!arg_roFirst.isEmpty())
  4170.  
  4171.   // concatenate the two strings
  4172.   strcat(sNewPtr, arg_sSecond);
  4173.  
  4174. return(StringC(ulNewLen,ulNewBufLen-1, sNewPtr));
  4175. }
  4176. /*E*/
  4177. StringC operator+(const char *arg_sFirst, const StringC &arg_roSecond)
  4178. /*S*/
  4179. /*S*/ /* Methoden-Rahmen */
  4180. /*************************************************************************
  4181. * Name der Methode: operator +
  4182. *
  4183. * Klasse: StringC
  4184. *
  4185. * Funktion: Aneinanderhängen einer Zeichenkette mit einem StringC-Object
  4186. *
  4187. * Zugriff: public
  4188. *
  4189. * Eingabe-Parameter: 2
  4190. *   eine Zeichenkette
  4191. *   Eine Referenz eines Objekten der Klasse StringC
  4192. *
  4193. * Ausgabe-Parameter: Ein neues StringC-Objekt
  4194. *
  4195. * Aufgerufen von:
  4196. *
  4197. * Verwendung folgender globaler Variablen/Strukturen:
  4198. *
  4199. * Benutzte Methoden: 7
  4200. *   ObjectXC()
  4201. *   StringC() Direkt-Set-Konstruktor [private]
  4202. *   StringC() Einfacher Konstruktor
  4203. *   isEmpty()
  4204. *   string.h/strcpy()
  4205. *   string.h/strcat()
  4206. *   getStringTableEntry()
  4207. *
  4208. * Version: 1.5
  4209. *
  4210. * Autor: Christian Taulien of Strange Intelligence
  4211. *
  4212. * Datum: 25. Juni 1997
  4213. *
  4214. * Letzte Änderungen/Neuerungen:
  4215. *  9. November 1996:  Methode implementiert
  4216. *   11. November 1996:  Sicherheit erhöht, durch Verwendung von getLen() und Existenz-Tests
  4217. *             wenn die Strings in den neuen kopiert werden.
  4218. *   12. Januar 1997:  Die Methode gibt nun einen Zeiger auf das neue Objekt, anstatt
  4219. *             eine Referenz darauf zurück.
  4220. *  6. Februar 1997:   Die Methode gibt keinen Zeiger mehr auf das neue Objekt zurück sondern
  4221. *             returniert ein komplett neues Objekt, weil vorher das mit new erzeugte
  4222. *             Return-Objekt nicht wieder gelöscht wurde. Für die Rückgabe wird der
  4223. *             Direktset-Konstruktor verwendet, so daß nur 1 temporäres Objekt auf dem
  4224. *             Stack erzeugt werden muß. Es scheint unmöglich für einen + operator ein
  4225. *             Temporäres Objekt zu vermeiden.
  4226. *             Desweiteren wurde die Länge jetzt richtig bemessen (vorher 1 Byte zuviel)
  4227. *   11-12. Juni 1997:   Methode aus dem Berlin-Projekt übernommen und angepasst
  4228. *             1 Bug wurde beseitigt (Semikolon in if-Zeile)
  4229. *   25. Juni 1997:    GetLength() wird nicht mehr verwendet. Die Länge
  4230. *             der Teilstrings wird direkt ausgelesen.
  4231. *             Die Methode wurde darüberhinaus optimiert und
  4232. *             weiter abgesichert.
  4233. *
  4234. *************************************************************************/
  4235. /*E*/
  4236. {
  4237. ASSERT(arg_roSecond.checkInstance())
  4238. ASSERT(arg_sFirst)
  4239.  
  4240.   ULONG ulNewLen=0;
  4241.  
  4242.   // only count the length of the char-pointer if one is there
  4243.   if (arg_sFirst)
  4244.   {
  4245.     ulNewLen = strlen(arg_sFirst);
  4246.   } // if (arg_sFirst)
  4247.  
  4248.   // if the char-pointer is zero or the string has no length
  4249.   if (!ulNewLen)
  4250.   {
  4251.     // just return a copy of the StringC-object
  4252.     return(StringC(arg_roSecond));
  4253.   } // if (!ulNewLen)
  4254.  
  4255.   // Compute the buffersize required to hold both strings
  4256.   ulNewLen += arg_roSecond.getLength();
  4257.  
  4258.   // make the string divideable by 8
  4259.   ULONG ulNewBufLen=(ulNewLen+8) & (~0x7);
  4260.  
  4261.   // allocate the new buffer
  4262.   char *sNewPtr = new char [ulNewBufLen];
  4263.   if (!sNewPtr)
  4264.   {
  4265.     // if something went wrong (no mem)
  4266.     throw STRINGC_XC;
  4267.   } // if (m_sStrPtr = new char [(ULONG) arg_ulSize])
  4268.  
  4269.   // put a copy of the char-pointer-string into the new buffer
  4270.   strcpy(sNewPtr, arg_sFirst);
  4271.  
  4272.   // fill the just allocated buffer
  4273.   if (!arg_roSecond.isEmpty())
  4274.   {
  4275.     strcat(sNewPtr, arg_roSecond.m_poData->m_sStrPtr);
  4276.   } //if (!arg_roFirst.isEmpty())
  4277.  
  4278. return(StringC(ulNewLen,ulNewBufLen-1, sNewPtr));
  4279. }
  4280. /*E*/
  4281. BOOL operator==(const StringC &arg_roFirst, const StringC &arg_roSecond)
  4282. /*S*/
  4283. /*S*/ /* Methoden-Rahmen */
  4284. /*************************************************************************
  4285. * Name der Methode: operator ==
  4286. *
  4287. * Klasse: StringC
  4288. *
  4289. * Funktion: Vergleichsoperator
  4290. *
  4291. * Zugriff: public
  4292. *
  4293. * Eingabe-Parameter: 2
  4294. *   2 Referenzen auf ein StringC-Objekte
  4295. *
  4296. * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE
  4297. *
  4298. * Aufgerufen von:
  4299. *
  4300. * Verwendung folgender globaler Variablen/Strukturen: keine
  4301. *
  4302. * Benutzte Methoden: 2
  4303. *   string.h/strcmp()
  4304. *   StringC::getBuffer()
  4305. *
  4306. * Version: 1.3
  4307. *
  4308. * Autor: Christian Taulien of Strange Intelligence
  4309. *
  4310. * Datum: 12. Juni 1997
  4311. *
  4312. * Letzte Änderungen/Neuerungen:
  4313. *   12. November 1996:  Methode impelmentiert
  4314. *   29. November 1996:  Exeptionhandling eingebaut
  4315. *  5. Dezember 1996:  Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme
  4316. *            wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen
  4317. *            einige auch NULL-Pointer haben.
  4318. *             s1 / s1.str  | s2 / s2.str  | Erg. beim Vergleich auf s1==s2
  4319. *             -------------+----------------+----------------------------------
  4320. *             0      | 0        | TRUE
  4321. *             0      | s2.str="..."   | FALSE
  4322. *             s1.str="..." | 0        | FALSE
  4323. *             s1.str="..." | s2.str="..."   | Abhängig vom Inhalt beider str
  4324. *   12. Juni 1997:    Methode aus dem Berlin-Project übernommen
  4325. *             Aufgrund der StringC-Implementierung kann es
  4326. *             keine NULL-Pointer geben
  4327. *
  4328. *************************************************************************/
  4329. /*E*/
  4330. {
  4331. ASSERT(arg_roFirst.checkInstance())
  4332. ASSERT(arg_roSecond.checkInstance())
  4333.  
  4334. return(!strcmp(arg_roFirst.getBuffer(), arg_roSecond.getBuffer()));
  4335. }
  4336. /*E*/
  4337. BOOL operator==(const StringC &arg_roFirst, const char *arg_sSecond)
  4338. /*S*/
  4339. /*S*/ /* Methoden-Rahmen */
  4340. /*************************************************************************
  4341. * Name der Methode: operator ==
  4342. *
  4343. * Klasse: StringC
  4344. *
  4345. * Funktion: Vergleichsoperator
  4346. *
  4347. * Zugriff: public
  4348. *
  4349. * Eingabe-Parameter: 2
  4350. *   1 Referenz auf ein StringC-Objekt
  4351. *   1 char-pointer
  4352. *
  4353. * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE
  4354. *
  4355. * Aufgerufen von:
  4356. *
  4357. * Verwendung folgender globaler Variablen/Strukturen: keine
  4358. *
  4359. * Benutzte Methoden: 2
  4360. *   string.h/strcmp()
  4361. *   StringC::getBuffer()
  4362. *
  4363. * Version: 1.3
  4364. *
  4365. * Autor: Christian Taulien of Strange Intelligence
  4366. *
  4367. * Datum: 12. Juni 1997
  4368. *
  4369. * Letzte Änderungen/Neuerungen:
  4370. *   12. November 1996:  Methode impelmentiert
  4371. *   29. November 1996:  Exeptionhandling eingebaut
  4372. *  5. Dezember 1996:  Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme
  4373. *            wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen
  4374. *            einige auch NULL-Pointer haben.
  4375. *             s1 / s1.str  | s2 / s2.str  | Erg. beim Vergleich auf s1==s2
  4376. *             -------------+----------------+----------------------------------
  4377. *             0      | 0        | TRUE
  4378. *             0      | s2.str="..."   | FALSE
  4379. *             s1.str="..." | 0        | FALSE
  4380. *             s1.str="..." | s2.str="..."   | Abhängig vom Inhalt beider str
  4381. *   12. Juni 1997:    Methode aus dem Berlin-Project übernommen
  4382. *             Aufgrund der StringC-Implementierung kann es dort
  4383. *             keine NULL-Pointer geben
  4384. *
  4385. *************************************************************************/
  4386. /*E*/
  4387. {
  4388. ASSERT(arg_roFirst.checkInstance())
  4389.   if (!arg_sSecond)
  4390.   {
  4391.     return(FALSE);
  4392.   } // if (!arg_sSecond)
  4393. return(!strcmp(arg_roFirst.getBuffer(),arg_sSecond));
  4394. }
  4395. /*E*/
  4396. BOOL operator==(const char *arg_sFirst, const StringC &arg_roSecond)
  4397. /*S*/
  4398. /*S*/ /* Methoden-Rahmen */
  4399. /*************************************************************************
  4400. * Name der Methode: operator ==
  4401. *
  4402. * Klasse: StringC
  4403. *
  4404. * Funktion: Vergleichsoperator
  4405. *
  4406. * Zugriff: public
  4407. *
  4408. * Eingabe-Parameter: 2
  4409. *   1 char pointer
  4410. *   1 Referenz auf ein StringC-Objekt
  4411. *
  4412. * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE
  4413. *
  4414. * Aufgerufen von:
  4415. *
  4416. * Verwendung folgender globaler Variablen/Strukturen: keine
  4417. *
  4418. * Benutzte Methoden: 2
  4419. *   string.h/strcmp()
  4420. *   StringC::getBuffer()
  4421. *
  4422. * Version: 1.3
  4423. *
  4424. * Autor: Christian Taulien of Strange Intelligence
  4425. *
  4426. * Datum: 12. Juni 1997
  4427. *
  4428. * Letzte Änderungen/Neuerungen:
  4429. *   12. November 1996:  Methode impelmentiert
  4430. *   29. November 1996:  Exeptionhandling eingebaut
  4431. *  5. Dezember 1996:  Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme
  4432. *            wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen
  4433. *            einige auch NULL-Pointer haben.
  4434. *             s1 / s1.str  | s2 / s2.str  | Erg. beim Vergleich auf s1==s2
  4435. *             -------------+----------------+----------------------------------
  4436. *             0      | 0        | TRUE
  4437. *             0      | s2.str="..."   | FALSE
  4438. *             s1.str="..." | 0        | FALSE
  4439. *             s1.str="..." | s2.str="..."   | Abhängig vom Inhalt beider str
  4440. *   12. Juni 1997:    Methode aus dem Berlin-Project übernommen
  4441. *             Aufgrund der StringC-Implementierung kann es dort
  4442. *             keine NULL-Pointer geben
  4443. *
  4444. *************************************************************************/
  4445. /*E*/
  4446. {
  4447. ASSERT(arg_roSecond.checkInstance())
  4448.   if (!arg_sFirst)
  4449.   {
  4450.     return(FALSE);
  4451.   } // if (!arg_sFirst)
  4452.  
  4453. return(!strcmp(arg_sFirst,arg_roSecond.getBuffer()));
  4454. }
  4455. /*E*/
  4456. BOOL operator!=(const StringC &arg_roFirst, const StringC &arg_roSecond)
  4457. /*S*/
  4458. /*S*/ /* Methoden-Rahmen */
  4459. /*************************************************************************
  4460. * Name der Methode: operator !=
  4461. *
  4462. * Klasse: StringC
  4463. *
  4464. * Funktion: Ungleichheits-operator
  4465. *
  4466. * Zugriff: public
  4467. *
  4468. * Eingabe-Parameter: 2
  4469. *   2 Referenzen auf ein StringC-Objekte
  4470. *
  4471. * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE
  4472. *
  4473. * Aufgerufen von:
  4474. *
  4475. * Verwendung folgender globaler Variablen/Strukturen: keine
  4476. *
  4477. * Benutzte Methoden: 2
  4478. *   string.h/strcmp()
  4479. *   StringC::getBuffer()
  4480. *
  4481. * Version: 1.3
  4482. *
  4483. * Autor: Christian Taulien of Strange Intelligence
  4484. *
  4485. * Datum: 12. Juni 1997
  4486. *
  4487. * Letzte Änderungen/Neuerungen:
  4488. *   12. November 1996:  Methode impelmentiert
  4489. *   29. November 1996:  Exeptionhandling eingebaut
  4490. *  5. Dezember 1996:  Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme
  4491. *            wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen
  4492. *            einige auch NULL-Pointer haben.
  4493. *             s1 / s1.str  | s2 / s2.str  | Erg. beim Vergleich auf s1==s2
  4494. *             -------------+----------------+----------------------------------
  4495. *             0      | 0        | TRUE
  4496. *             0      | s2.str="..."   | FALSE
  4497. *             s1.str="..." | 0        | FALSE
  4498. *             s1.str="..." | s2.str="..."   | Abhängig vom Inhalt beider str
  4499. *   12. Juni 1997:    Methode aus dem Berlin-Project übernommen
  4500. *             Aufgrund der StringC-Implementierung kann es dort
  4501. *             keine NULL-Pointer geben
  4502. *
  4503. *************************************************************************/
  4504. /*E*/
  4505. {
  4506. ASSERT(arg_roFirst.checkInstance())
  4507. ASSERT(arg_roSecond.checkInstance())
  4508.  
  4509. return(strcmp(arg_roFirst.getBuffer(), arg_roSecond.getBuffer()));
  4510. }
  4511. /*E*/
  4512. BOOL operator!=(const StringC &arg_roFirst, const char *arg_sSecond)
  4513. /*S*/
  4514. /*S*/ /* Methoden-Rahmen */
  4515. /*************************************************************************
  4516. * Name der Methode: operator 2=
  4517. *
  4518. * Klasse: StringC
  4519. *
  4520. * Funktion: Ungleichheits-operator
  4521. *
  4522. * Zugriff: public
  4523. *
  4524. * Eingabe-Parameter: 2
  4525. *   1 Referenz auf ein StringC-Objekt
  4526. *   1 char-pointer
  4527. *
  4528. * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE
  4529. *
  4530. * Aufgerufen von:
  4531. *
  4532. * Verwendung folgender globaler Variablen/Strukturen: keine
  4533. *
  4534. * Benutzte Methoden: 2
  4535. *   string.h/strcmp()
  4536. *   StringC::getBuffer()
  4537. *
  4538. * Version: 1.3
  4539. *
  4540. * Autor: Christian Taulien of Strange Intelligence
  4541. *
  4542. * Datum: 12. Juni 1997
  4543. *
  4544. * Letzte Änderungen/Neuerungen:
  4545. *   12. November 1996:  Methode impelmentiert
  4546. *   29. November 1996:  Exeptionhandling eingebaut
  4547. *  5. Dezember 1996:  Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme
  4548. *            wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen
  4549. *            einige auch NULL-Pointer haben.
  4550. *             s1 / s1.str  | s2 / s2.str  | Erg. beim Vergleich auf s1==s2
  4551. *             -------------+----------------+----------------------------------
  4552. *             0      | 0        | TRUE
  4553. *             0      | s2.str="..."   | FALSE
  4554. *             s1.str="..." | 0        | FALSE
  4555. *             s1.str="..." | s2.str="..."   | Abhängig vom Inhalt beider str
  4556. *   12. Juni 1997:    Methode aus dem Berlin-Project übernommen
  4557. *             Aufgrund der StringC-Implementierung kann es dort
  4558. *             keine NULL-Pointer geben
  4559. *
  4560. *************************************************************************/
  4561. /*E*/
  4562. {
  4563. ASSERT(arg_roFirst.checkInstance())
  4564.   if (!arg_sSecond)
  4565.   {
  4566.     return(TRUE);
  4567.   } // if (!arg_sSecond)
  4568. return(strcmp(arg_roFirst.getBuffer(),arg_sSecond));
  4569. }
  4570. /*E*/
  4571. BOOL operator!=(const char *arg_sFirst, const StringC &arg_roSecond)
  4572. /*S*/
  4573. /*S*/ /* Methoden-Rahmen */
  4574. /*************************************************************************
  4575. * Name der Methode: operator !=
  4576. *
  4577. * Klasse: StringC
  4578. *
  4579. * Funktion: Ungleichheits-operator
  4580. *
  4581. * Zugriff: public
  4582. *
  4583. * Eingabe-Parameter: 2
  4584. *   1 char pointer
  4585. *   1 Referenz auf ein StringC-Objekt
  4586. *
  4587. * Ausgabe-Parameter: TRUE wenn s1!=s2; sonst FALSE
  4588. *
  4589. * Aufgerufen von:
  4590. *
  4591. * Verwendung folgender globaler Variablen/Strukturen: keine
  4592. *
  4593. * Benutzte Methoden: 2
  4594. *   string.h/strcmp()
  4595. *   StringC::getBuffer()
  4596. *
  4597. * Version: 1.3
  4598. *
  4599. * Autor: Christian Taulien of Strange Intelligence
  4600. *
  4601. * Datum: 12. Juni 1997
  4602. *
  4603. * Letzte Änderungen/Neuerungen:
  4604. *   12. November 1996:  Methode impelmentiert
  4605. *   29. November 1996:  Exeptionhandling eingebaut
  4606. *  5. Dezember 1996:  Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme
  4607. *            wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen
  4608. *            einige auch NULL-Pointer haben.
  4609. *             s1 / s1.str  | s2 / s2.str  | Erg. beim Vergleich auf s1==s2
  4610. *             -------------+----------------+----------------------------------
  4611. *             0      | 0        | TRUE
  4612. *             0      | s2.str="..."   | FALSE
  4613. *             s1.str="..." | 0        | FALSE
  4614. *             s1.str="..." | s2.str="..."   | Abhängig vom Inhalt beider str
  4615. *   12. Juni 1997:    Methode aus dem Berlin-Project übernommen
  4616. *             Aufgrund der StringC-Implementierung kann es dort
  4617. *             keine NULL-Pointer geben
  4618. *
  4619. *************************************************************************/
  4620. /*E*/
  4621. {
  4622. ASSERT(arg_roSecond.checkInstance())
  4623.   if (!arg_sFirst)
  4624.   {
  4625.     return(TRUE);
  4626.   } // if (!arg_sFirst)
  4627. return(strcmp(arg_sFirst,arg_roSecond.getBuffer()));
  4628. }
  4629. /*E*/
  4630. BOOL operator<(const StringC &arg_roFirst, const StringC &arg_roSecond)
  4631. /*S*/
  4632. /*S*/ /* Methoden-Rahmen */
  4633. /*************************************************************************
  4634. * Name der Methode: operator <
  4635. *
  4636. * Klasse: StringC
  4637. *
  4638. * Funktion: Kleiner-als-operator
  4639. *
  4640. * Zugriff: public
  4641. *
  4642. * Eingabe-Parameter: 2
  4643. *   2 Referenzen auf ein StringC-Objekte
  4644. *
  4645. * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE
  4646. *
  4647. * Aufgerufen von:
  4648. *
  4649. * Verwendung folgender globaler Variablen/Strukturen: keine
  4650. *
  4651. * Benutzte Methoden: 2
  4652. *   string.h/strcmp()
  4653. *   StringC::getBuffer()
  4654. *
  4655. * Version: 1.3
  4656. *
  4657. * Autor: Christian Taulien of Strange Intelligence
  4658. *
  4659. * Datum: 12. Juni 1997
  4660. *
  4661. * Letzte Änderungen/Neuerungen:
  4662. *   12. November 1996:  Methode impelmentiert
  4663. *   29. November 1996:  Exeptionhandling eingebaut
  4664. *  5. Dezember 1996:  Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme
  4665. *            wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen
  4666. *            einige auch NULL-Pointer haben.
  4667. *             s1 / s1.str  | s2 / s2.str  | Erg. beim Vergleich auf s1==s2
  4668. *             -------------+----------------+----------------------------------
  4669. *             0      | 0        | TRUE
  4670. *             0      | s2.str="..."   | FALSE
  4671. *             s1.str="..." | 0        | FALSE
  4672. *             s1.str="..." | s2.str="..."   | Abhängig vom Inhalt beider str
  4673. *   12. Juni 1997:    Methode aus dem Berlin-Project übernommen
  4674. *             Aufgrund der StringC-Implementierung kann es dort
  4675. *             keine NULL-Pointer geben
  4676. *
  4677. *************************************************************************/
  4678. /*E*/
  4679. {
  4680. ASSERT(arg_roFirst.checkInstance())
  4681. ASSERT(arg_roSecond.checkInstance())
  4682.  
  4683. return(strcmp(arg_roFirst.getBuffer(), arg_roSecond.getBuffer()) < 0);
  4684. }
  4685. /*E*/
  4686. BOOL operator<(const StringC &arg_roFirst, const char *arg_sSecond)
  4687. /*S*/
  4688. /*S*/ /* Methoden-Rahmen */
  4689. /*************************************************************************
  4690. * Name der Methode: operator <
  4691. *
  4692. * Klasse: StringC
  4693. *
  4694. * Funktion: Kleiner-als-operator
  4695. *
  4696. * Zugriff: public
  4697. *
  4698. * Eingabe-Parameter: 2
  4699. *   1 Referenz auf ein StringC-Objekt
  4700. *   1 char-pointer
  4701. *
  4702. * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE
  4703. *
  4704. * Aufgerufen von:
  4705. *
  4706. * Verwendung folgender globaler Variablen/Strukturen: keine
  4707. *
  4708. * Benutzte Methoden: 2
  4709. *   string.h/strcmp()
  4710. *   StringC::getBuffer()
  4711. *
  4712. * Version: 1.3
  4713. *
  4714. * Autor: Christian Taulien of Strange Intelligence
  4715. *
  4716. * Datum: 12. Juni 1997
  4717. *
  4718. * Letzte Änderungen/Neuerungen:
  4719. *   12. November 1996:  Methode impelmentiert
  4720. *   29. November 1996:  Exeptionhandling eingebaut
  4721. *  5. Dezember 1996:  Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme
  4722. *            wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen
  4723. *            einige auch NULL-Pointer haben.
  4724. *             s1 / s1.str  | s2 / s2.str  | Erg. beim Vergleich auf s1==s2
  4725. *             -------------+----------------+----------------------------------
  4726. *             0      | 0        | TRUE
  4727. *             0      | s2.str="..."   | FALSE
  4728. *             s1.str="..." | 0        | FALSE
  4729. *             s1.str="..." | s2.str="..."   | Abhängig vom Inhalt beider str
  4730. *   12. Juni 1997:    Methode aus dem Berlin-Project übernommen
  4731. *             Aufgrund der StringC-Implementierung kann es dort
  4732. *             keine NULL-Pointer geben
  4733. *
  4734. *************************************************************************/
  4735. /*E*/
  4736. {
  4737. ASSERT(arg_roFirst.checkInstance())
  4738.   if (!arg_sSecond)
  4739.   {
  4740.     return(FALSE);
  4741.   } // if (!arg_sSecond)
  4742. return(strcmp(arg_roFirst.getBuffer(),arg_sSecond) < 0);
  4743. }
  4744. /*E*/
  4745. BOOL operator<(const char *arg_sFirst, const StringC &arg_roSecond)
  4746. /*S*/
  4747. /*S*/ /* Methoden-Rahmen */
  4748. /*************************************************************************
  4749. * Name der Methode: operator <
  4750. *
  4751. * Klasse: StringC
  4752. *
  4753. * Funktion: Kleiner-als-operator
  4754. *
  4755. * Zugriff: public
  4756. *
  4757. * Eingabe-Parameter: 2
  4758. *   1 char pointer
  4759. *   1 Referenz auf ein StringC-Objekt
  4760. *
  4761. * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE
  4762. *
  4763. * Aufgerufen von:
  4764. *
  4765. * Verwendung folgender globaler Variablen/Strukturen: keine
  4766. *
  4767. * Benutzte Methoden: 2
  4768. *   string.h/strcmp()
  4769. *   StringC::getBuffer()
  4770. *
  4771. * Version: 1.3
  4772. *
  4773. * Autor: Christian Taulien of Strange Intelligence
  4774. *
  4775. * Datum: 12. Juni 1997
  4776. *
  4777. * Letzte Änderungen/Neuerungen:
  4778. *   12. November 1996:  Methode impelmentiert
  4779. *   29. November 1996:  Exeptionhandling eingebaut
  4780. *  5. Dezember 1996:  Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme
  4781. *            wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen
  4782. *            einige auch NULL-Pointer haben.
  4783. *             s1 / s1.str  | s2 / s2.str  | Erg. beim Vergleich auf s1==s2
  4784. *             -------------+----------------+----------------------------------
  4785. *             0      | 0        | TRUE
  4786. *             0      | s2.str="..."   | FALSE
  4787. *             s1.str="..." | 0        | FALSE
  4788. *             s1.str="..." | s2.str="..."   | Abhängig vom Inhalt beider str
  4789. *   12. Juni 1997:    Methode aus dem Berlin-Project übernommen
  4790. *             Aufgrund der StringC-Implementierung kann es dort
  4791. *             keine NULL-Pointer geben
  4792. *
  4793. *************************************************************************/
  4794. /*E*/
  4795. {
  4796. ASSERT(arg_roSecond.checkInstance())
  4797.   if (!arg_sFirst)
  4798.   {
  4799.     return(TRUE);
  4800.   } // if (!arg_sFirst)
  4801. return(strcmp(arg_sFirst,arg_roSecond.getBuffer()) < 0);
  4802. }
  4803. /*E*/
  4804. BOOL operator>(const StringC &arg_roFirst, const StringC &arg_roSecond)
  4805. /*S*/
  4806. /*S*/ /* Methoden-Rahmen */
  4807. /*************************************************************************
  4808. * Name der Methode: operator >
  4809. *
  4810. * Klasse: StringC
  4811. *
  4812. * Funktion: Größer-als-operator
  4813. *
  4814. * Zugriff: public
  4815. *
  4816. * Eingabe-Parameter: 2
  4817. *   2 Referenzen auf ein StringC-Objekte
  4818. *
  4819. * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE
  4820. *
  4821. * Aufgerufen von:
  4822. *
  4823. * Verwendung folgender globaler Variablen/Strukturen: keine
  4824. *
  4825. * Benutzte Methoden: 2
  4826. *   string.h/strcmp()
  4827. *   StringC::getBuffer()
  4828. *
  4829. * Version: 1.3
  4830. *
  4831. * Autor: Christian Taulien of Strange Intelligence
  4832. *
  4833. * Datum: 12. Juni 1997
  4834. *
  4835. * Letzte Änderungen/Neuerungen:
  4836. *   12. November 1996:  Methode impelmentiert
  4837. *   29. November 1996:  Exeptionhandling eingebaut
  4838. *  5. Dezember 1996:  Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme
  4839. *            wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen
  4840. *            einige auch NULL-Pointer haben.
  4841. *             s1 / s1.str  | s2 / s2.str  | Erg. beim Vergleich auf s1==s2
  4842. *             -------------+----------------+----------------------------------
  4843. *             0      | 0        | TRUE
  4844. *             0      | s2.str="..."   | FALSE
  4845. *             s1.str="..." | 0        | FALSE
  4846. *             s1.str="..." | s2.str="..."   | Abhängig vom Inhalt beider str
  4847. *   12. Juni 1997:    Methode aus dem Berlin-Project übernommen
  4848. *             Aufgrund der StringC-Implementierung kann es dort
  4849. *             keine NULL-Pointer geben
  4850. *
  4851. *************************************************************************/
  4852. /*E*/
  4853. {
  4854. ASSERT(arg_roFirst.checkInstance())
  4855. ASSERT(arg_roSecond.checkInstance())
  4856.  
  4857. return(strcmp(arg_roFirst.getBuffer(), arg_roSecond.getBuffer()) > 0);
  4858. }
  4859. /*E*/
  4860. BOOL operator>(const StringC &arg_roFirst, const char *arg_sSecond)
  4861. /*S*/
  4862. /*S*/ /* Methoden-Rahmen */
  4863. /*************************************************************************
  4864. * Name der Methode: operator >
  4865. *
  4866. * Klasse: StringC
  4867. *
  4868. * Funktion: Größer-als-operator
  4869. *
  4870. * Zugriff: public
  4871. *
  4872. * Eingabe-Parameter: 2
  4873. *   1 Referenz auf ein StringC-Objekt
  4874. *   1 char-pointer
  4875. *
  4876. * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE
  4877. *
  4878. * Aufgerufen von:
  4879. *
  4880. * Verwendung folgender globaler Variablen/Strukturen: keine
  4881. *
  4882. * Benutzte Methoden: 2
  4883. *   string.h/strcmp()
  4884. *   StringC::getBuffer()
  4885. *
  4886. * Version: 1.3
  4887. *
  4888. * Autor: Christian Taulien of Strange Intelligence
  4889. *
  4890. * Datum: 12. Juni 1997
  4891. *
  4892. * Letzte Änderungen/Neuerungen:
  4893. *   12. November 1996:  Methode impelmentiert
  4894. *   29. November 1996:  Exeptionhandling eingebaut
  4895. *  5. Dezember 1996:  Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme
  4896. *            wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen
  4897. *            einige auch NULL-Pointer haben.
  4898. *             s1 / s1.str  | s2 / s2.str  | Erg. beim Vergleich auf s1==s2
  4899. *             -------------+----------------+----------------------------------
  4900. *             0      | 0        | TRUE
  4901. *             0      | s2.str="..."   | FALSE
  4902. *             s1.str="..." | 0        | FALSE
  4903. *             s1.str="..." | s2.str="..."   | Abhängig vom Inhalt beider str
  4904. *   12. Juni 1997:    Methode aus dem Berlin-Project übernommen
  4905. *             Aufgrund der StringC-Implementierung kann es dort
  4906. *             keine NULL-Pointer geben
  4907. *
  4908. *************************************************************************/
  4909. /*E*/
  4910. {
  4911. ASSERT(arg_roFirst.checkInstance())
  4912.   if (!arg_sSecond)
  4913.   {
  4914.     return(TRUE);
  4915.   } // if (!arg_sSecond)
  4916. return(strcmp(arg_roFirst.getBuffer(),arg_sSecond) > 0);
  4917. }
  4918. /*E*/
  4919. BOOL operator>(const char *arg_sFirst, const StringC &arg_roSecond)
  4920. /*S*/
  4921. /*S*/ /* Methoden-Rahmen */
  4922. /*************************************************************************
  4923. * Name der Methode: operator >
  4924. *
  4925. * Klasse: StringC
  4926. *
  4927. * Funktion: Größer-als-operator
  4928. *
  4929. * Zugriff: public
  4930. *
  4931. * Eingabe-Parameter: 2
  4932. *   1 char pointer
  4933. *   1 Referenz auf ein StringC-Objekt
  4934. *
  4935. * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE
  4936. *
  4937. * Aufgerufen von:
  4938. *
  4939. * Verwendung folgender globaler Variablen/Strukturen: keine
  4940. *
  4941. * Benutzte Methoden: 2
  4942. *   string.h/strcmp()
  4943. *   StringC::getBuffer()
  4944. *
  4945. * Version: 1.3
  4946. *
  4947. * Autor: Christian Taulien of Strange Intelligence
  4948. *
  4949. * Datum: 12. Juni 1997
  4950. *
  4951. * Letzte Änderungen/Neuerungen:
  4952. *   12. November 1996:  Methode impelmentiert
  4953. *   29. November 1996:  Exeptionhandling eingebaut
  4954. *  5. Dezember 1996:  Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme
  4955. *            wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen
  4956. *            einige auch NULL-Pointer haben.
  4957. *             s1 / s1.str  | s2 / s2.str  | Erg. beim Vergleich auf s1==s2
  4958. *             -------------+----------------+----------------------------------
  4959. *             0      | 0        | TRUE
  4960. *             0      | s2.str="..."   | FALSE
  4961. *             s1.str="..." | 0        | FALSE
  4962. *             s1.str="..." | s2.str="..."   | Abhängig vom Inhalt beider str
  4963. *   12. Juni 1997:    Methode aus dem Berlin-Project übernommen
  4964. *             Aufgrund der StringC-Implementierung kann es dort
  4965. *             keine NULL-Pointer geben
  4966. *
  4967. *************************************************************************/
  4968. /*E*/
  4969. {
  4970. ASSERT(arg_roSecond.checkInstance())
  4971.   if (!arg_sFirst)
  4972.   {
  4973.     return(FALSE);
  4974.   } // if (!arg_sFirst)
  4975. return(strcmp(arg_sFirst,arg_roSecond.getBuffer()) > 0);
  4976. }
  4977. /*E*/
  4978. BOOL operator<=(const StringC &arg_roFirst, const StringC &arg_roSecond)
  4979. /*S*/
  4980. /*S*/ /* Methoden-Rahmen */
  4981. /*************************************************************************
  4982. * Name der Methode: operator <=
  4983. *
  4984. * Klasse: StringC
  4985. *
  4986. * Funktion: kleiner-gleich-operator
  4987. *
  4988. * Zugriff: public
  4989. *
  4990. * Eingabe-Parameter: 2
  4991. *   2 Referenzen auf ein StringC-Objekte
  4992. *
  4993. * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE
  4994. *
  4995. * Aufgerufen von:
  4996. *
  4997. * Verwendung folgender globaler Variablen/Strukturen: keine
  4998. *
  4999. * Benutzte Methoden: 2
  5000. *   string.h/strcmp()
  5001. *   StringC::getBuffer()
  5002. *
  5003. * Version: 1.3
  5004. *
  5005. * Autor: Christian Taulien of Strange Intelligence
  5006. *
  5007. * Datum: 12. Juni 1997
  5008. *
  5009. * Letzte Änderungen/Neuerungen:
  5010. *   12. November 1996:  Methode impelmentiert
  5011. *   29. November 1996:  Exeptionhandling eingebaut
  5012. *  5. Dezember 1996:  Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme
  5013. *            wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen
  5014. *            einige auch NULL-Pointer haben.
  5015. *             s1 / s1.str  | s2 / s2.str  | Erg. beim Vergleich auf s1==s2
  5016. *             -------------+----------------+----------------------------------
  5017. *             0      | 0        | TRUE
  5018. *             0      | s2.str="..."   | FALSE
  5019. *             s1.str="..." | 0        | FALSE
  5020. *             s1.str="..." | s2.str="..."   | Abhängig vom Inhalt beider str
  5021. *   12. Juni 1997:    Methode aus dem Berlin-Project übernommen
  5022. *             Aufgrund der StringC-Implementierung kann es dort
  5023. *             keine NULL-Pointer geben
  5024. *
  5025. *************************************************************************/
  5026. /*E*/
  5027. {
  5028. ASSERT(arg_roFirst.checkInstance())
  5029. ASSERT(arg_roSecond.checkInstance())
  5030.  
  5031. return(strcmp(arg_roFirst.getBuffer(), arg_roSecond.getBuffer()) <= 0);
  5032. }
  5033. /*E*/
  5034. BOOL operator<=(const StringC &arg_roFirst, const char *arg_sSecond)
  5035. /*S*/
  5036. /*S*/ /* Methoden-Rahmen */
  5037. /*************************************************************************
  5038. * Name der Methode: operator <=
  5039. *
  5040. * Klasse: StringC
  5041. *
  5042. * Funktion: kleiner-gleich-operator
  5043. *
  5044. * Zugriff: public
  5045. *
  5046. * Eingabe-Parameter: 2
  5047. *   1 Referenz auf ein StringC-Objekt
  5048. *   1 char-pointer
  5049. *
  5050. * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE
  5051. *
  5052. * Aufgerufen von:
  5053. *
  5054. * Verwendung folgender globaler Variablen/Strukturen: keine
  5055. *
  5056. * Benutzte Methoden: 2
  5057. *   string.h/strcmp()
  5058. *   StringC::getBuffer()
  5059. *
  5060. * Version: 1.3
  5061. *
  5062. * Autor: Christian Taulien of Strange Intelligence
  5063. *
  5064. * Datum: 12. Juni 1997
  5065. *
  5066. * Letzte Änderungen/Neuerungen:
  5067. *   12. November 1996:  Methode impelmentiert
  5068. *   29. November 1996:  Exeptionhandling eingebaut
  5069. *  5. Dezember 1996:  Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme
  5070. *            wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen
  5071. *            einige auch NULL-Pointer haben.
  5072. *             s1 / s1.str  | s2 / s2.str  | Erg. beim Vergleich auf s1==s2
  5073. *             -------------+----------------+----------------------------------
  5074. *             0      | 0        | TRUE
  5075. *             0      | s2.str="..."   | FALSE
  5076. *             s1.str="..." | 0        | FALSE
  5077. *             s1.str="..." | s2.str="..."   | Abhängig vom Inhalt beider str
  5078. *   12. Juni 1997:    Methode aus dem Berlin-Project übernommen
  5079. *             Aufgrund der StringC-Implementierung kann es dort
  5080. *             keine NULL-Pointer geben
  5081. *
  5082. *************************************************************************/
  5083. /*E*/
  5084. {
  5085. ASSERT(arg_roFirst.checkInstance())
  5086.   if (!arg_sSecond)
  5087.   {
  5088.     return(FALSE);
  5089.   } // if (!arg_sSecond)
  5090. return(strcmp(arg_roFirst.getBuffer(),arg_sSecond) <= 0);
  5091. }
  5092. /*E*/
  5093. BOOL operator<=(const char *arg_sFirst, const StringC &arg_roSecond)
  5094. /*S*/
  5095. /*S*/ /* Methoden-Rahmen */
  5096. /*************************************************************************
  5097. * Name der Methode: operator <=
  5098. *
  5099. * Klasse: StringC
  5100. *
  5101. * Funktion: kleiner-gleich-operator
  5102. *
  5103. * Zugriff: public
  5104. *
  5105. * Eingabe-Parameter: 2
  5106. *   1 char pointer
  5107. *   1 Referenz auf ein StringC-Objekt
  5108. *
  5109. * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE
  5110. *
  5111. * Aufgerufen von:
  5112. *
  5113. * Verwendung folgender globaler Variablen/Strukturen: keine
  5114. *
  5115. * Benutzte Methoden: 2
  5116. *   string.h/strcmp()
  5117. *   StringC::getBuffer()
  5118. *
  5119. * Version: 1.3
  5120. *
  5121. * Autor: Christian Taulien of Strange Intelligence
  5122. *
  5123. * Datum: 12. Juni 1997
  5124. *
  5125. * Letzte Änderungen/Neuerungen:
  5126. *   12. November 1996:  Methode impelmentiert
  5127. *   29. November 1996:  Exeptionhandling eingebaut
  5128. *  5. Dezember 1996:  Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme
  5129. *            wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen
  5130. *            einige auch NULL-Pointer haben.
  5131. *             s1 / s1.str  | s2 / s2.str  | Erg. beim Vergleich auf s1==s2
  5132. *             -------------+----------------+----------------------------------
  5133. *             0      | 0        | TRUE
  5134. *             0      | s2.str="..."   | FALSE
  5135. *             s1.str="..." | 0        | FALSE
  5136. *             s1.str="..." | s2.str="..."   | Abhängig vom Inhalt beider str
  5137. *   12. Juni 1997:    Methode aus dem Berlin-Project übernommen
  5138. *             Aufgrund der StringC-Implementierung kann es dort
  5139. *             keine NULL-Pointer geben
  5140. *
  5141. *************************************************************************/
  5142. /*E*/
  5143. {
  5144. ASSERT(arg_roSecond.checkInstance())
  5145.   if (!arg_sFirst)
  5146.   {
  5147.     return(TRUE);
  5148.   } // if (!arg_sFirst)
  5149. return(strcmp(arg_sFirst,arg_roSecond.getBuffer()) <= 0);
  5150. }
  5151. /*E*/
  5152. BOOL operator>=(const StringC &arg_roFirst, const StringC &arg_roSecond)
  5153. /*S*/
  5154. /*S*/ /* Methoden-Rahmen */
  5155. /*************************************************************************
  5156. * Name der Methode: operator >=
  5157. *
  5158. * Klasse: StringC
  5159. *
  5160. * Funktion: Größer-gleich-operator
  5161. *
  5162. * Zugriff: public
  5163. *
  5164. * Eingabe-Parameter: 2
  5165. *   2 Referenzen auf ein StringC-Objekte
  5166. *
  5167. * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE
  5168. *
  5169. * Aufgerufen von:
  5170. *
  5171. * Verwendung folgender globaler Variablen/Strukturen: keine
  5172. *
  5173. * Benutzte Methoden: 2
  5174. *   string.h/strcmp()
  5175. *   StringC::getBuffer()
  5176. *
  5177. * Version: 1.3
  5178. *
  5179. * Autor: Christian Taulien of Strange Intelligence
  5180. *
  5181. * Datum: 12. Juni 1997
  5182. *
  5183. * Letzte Änderungen/Neuerungen:
  5184. *   12. November 1996:  Methode impelmentiert
  5185. *   29. November 1996:  Exeptionhandling eingebaut
  5186. *  5. Dezember 1996:  Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme
  5187. *            wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen
  5188. *            einige auch NULL-Pointer haben.
  5189. *             s1 / s1.str  | s2 / s2.str  | Erg. beim Vergleich auf s1==s2
  5190. *             -------------+----------------+----------------------------------
  5191. *             0      | 0        | TRUE
  5192. *             0      | s2.str="..."   | FALSE
  5193. *             s1.str="..." | 0        | FALSE
  5194. *             s1.str="..." | s2.str="..."   | Abhängig vom Inhalt beider str
  5195. *   12. Juni 1997:    Methode aus dem Berlin-Project übernommen
  5196. *             Aufgrund der StringC-Implementierung kann es dort
  5197. *             keine NULL-Pointer geben
  5198. *
  5199. *************************************************************************/
  5200. /*E*/
  5201. {
  5202. ASSERT(arg_roFirst.checkInstance())
  5203. ASSERT(arg_roSecond.checkInstance())
  5204.  
  5205. return(strcmp(arg_roFirst.getBuffer(), arg_roSecond.getBuffer()) >= 0);
  5206. }
  5207. /*E*/
  5208. BOOL operator>=(const StringC &arg_roFirst, const char *arg_sSecond)
  5209. /*S*/
  5210. /*S*/ /* Methoden-Rahmen */
  5211. /*************************************************************************
  5212. * Name der Methode: operator >=
  5213. *
  5214. * Klasse: StringC
  5215. *
  5216. * Funktion: Größer-gleich-operator
  5217. *
  5218. * Zugriff: public
  5219. *
  5220. * Eingabe-Parameter: 2
  5221. *   1 Referenz auf ein StringC-Objekt
  5222. *   1 char-pointer
  5223. *
  5224. * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE
  5225. *
  5226. * Aufgerufen von:
  5227. *
  5228. * Verwendung folgender globaler Variablen/Strukturen: keine
  5229. *
  5230. * Benutzte Methoden: 2
  5231. *   string.h/strcmp()
  5232. *   StringC::getBuffer()
  5233. *
  5234. * Version: 1.3
  5235. *
  5236. * Autor: Christian Taulien of Strange Intelligence
  5237. *
  5238. * Datum: 12. Juni 1997
  5239. *
  5240. * Letzte Änderungen/Neuerungen:
  5241. *   12. November 1996:  Methode impelmentiert
  5242. *   29. November 1996:  Exeptionhandling eingebaut
  5243. *  5. Dezember 1996:  Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme
  5244. *            wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen
  5245. *            einige auch NULL-Pointer haben.
  5246. *             s1 / s1.str  | s2 / s2.str  | Erg. beim Vergleich auf s1==s2
  5247. *             -------------+----------------+----------------------------------
  5248. *             0      | 0        | TRUE
  5249. *             0      | s2.str="..."   | FALSE
  5250. *             s1.str="..." | 0        | FALSE
  5251. *             s1.str="..." | s2.str="..."   | Abhängig vom Inhalt beider str
  5252. *   12. Juni 1997:    Methode aus dem Berlin-Project übernommen
  5253. *             Aufgrund der StringC-Implementierung kann es dort
  5254. *             keine NULL-Pointer geben
  5255. *
  5256. *************************************************************************/
  5257. /*E*/
  5258. {
  5259. ASSERT(arg_roFirst.checkInstance())
  5260.   if (!arg_sSecond)
  5261.   {
  5262.     return(TRUE);
  5263.   } // if (!arg_sSecond)
  5264. return(strcmp(arg_roFirst.getBuffer(),arg_sSecond) >= 0);
  5265. }
  5266. /*E*/
  5267. BOOL operator>=(const char *arg_sFirst, const StringC &arg_roSecond)
  5268. /*S*/
  5269. /*S*/ /* Methoden-Rahmen */
  5270. /*************************************************************************
  5271. * Name der Methode: operator >=
  5272. *
  5273. * Klasse: StringC
  5274. *
  5275. * Funktion: Größer-gleich-operator
  5276. *
  5277. * Zugriff: public
  5278. *
  5279. * Eingabe-Parameter: 2
  5280. *   1 char pointer
  5281. *   1 Referenz auf ein StringC-Objekt
  5282. *
  5283. * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE
  5284. *
  5285. * Aufgerufen von:
  5286. *
  5287. * Verwendung folgender globaler Variablen/Strukturen: keine
  5288. *
  5289. * Benutzte Methoden: 2
  5290. *   string.h/strcmp()
  5291. *   StringC::getBuffer()
  5292. *
  5293. * Version: 1.3
  5294. *
  5295. * Autor: Christian Taulien of Strange Intelligence
  5296. *
  5297. * Datum: 12. Juni 1997
  5298. *
  5299. * Letzte Änderungen/Neuerungen:
  5300. *   12. November 1996:  Methode impelmentiert
  5301. *   29. November 1996:  Exeptionhandling eingebaut
  5302. *  5. Dezember 1996:  Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme
  5303. *            wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen
  5304. *            einige auch NULL-Pointer haben.
  5305. *             s1 / s1.str  | s2 / s2.str  | Erg. beim Vergleich auf s1==s2
  5306. *             -------------+----------------+----------------------------------
  5307. *             0      | 0        | TRUE
  5308. *             0      | s2.str="..."   | FALSE
  5309. *             s1.str="..." | 0        | FALSE
  5310. *             s1.str="..." | s2.str="..."   | Abhängig vom Inhalt beider str
  5311. *   12. Juni 1997:    Methode aus dem Berlin-Project übernommen
  5312. *             Aufgrund der StringC-Implementierung kann es dort
  5313. *             keine NULL-Pointer geben
  5314. *
  5315. *************************************************************************/
  5316. /*E*/
  5317. {
  5318. ASSERT(arg_roSecond.checkInstance())
  5319.   if (!arg_sFirst)
  5320.   {
  5321.     return(FALSE);
  5322.   } // if (!arg_sFirst)
  5323. return(strcmp(arg_sFirst,arg_roSecond.getBuffer()) >= 0);
  5324. }
  5325. /*E*/
  5326.  
  5327. //#ifdef si_debug_x
  5328. //#undef si_debug_x
  5329. //#define si_debug
  5330. //#endif
  5331.  
  5332.